Skip to content

getaero-io/gtm-eng-skills / skills/deepline-gtm

deepline-gtm

Unverified

GTM leads, enrichment, outreach, Plays, developer signals/Reo.dev. Providers: adyntel,affinity,ai_ark,akta,allegrow,amplemarket,apify,attention,attio,aviato,bettercontact,bigquery,bluesky,bounceban,brave,browserbase,builtwith,buyercaddy,cbinsights,clay,clickhouse,close,cloudflare,contactout,contextdev,crunchbase,crustdata-v3,customer_db,databricks,dataforseo,datagma,dealroom,deepline_ip_to_company,deepline_native,deeplineagent,deepseek,discolike,dnb,edges,emailbison,emailguard,enformion,enigma,exa,findymail,firecrawl,fireflies,firmable,forager,fullenrich,fundable,generic_http,getleads,gong,google_ads_audiences,google_workspace,govfiles,grain,hackernews,harvestapi,heyreach,hubspot,hunter,icypeas,instantly,intercom,ipqs,kaspr,kernel,kickbox,leadmagic,lemlist,limadata,linkedin_ads_audiences,luma,lusha,meerapi,meta_audiences,millionverifier,nooks,notion,openmart,opensosdata,openwebninja,outreach,parallel,particle,peopledatalabs,pitchbook,podscan,polymarket,postgres,predictleads,prospeo,quickenrich,rapidapi,….

FileKindSize
SKILL.mdskill md15.9 KB
claude-deepline-statusline.mjsexecutablescript25.0 KB
prompts.jsonconfig297.9 KB
provider-playbooks/adyntel.mdmarkdown1.2 KB
provider-playbooks/affinity.mdmarkdown825 B
provider-playbooks/ai-ark.mdmarkdown10.6 KB
provider-playbooks/akta.mdmarkdown1.5 KB
provider-playbooks/allegrow.mdmarkdown4.6 KB
provider-playbooks/amplemarket.mdmarkdown2.8 KB
provider-playbooks/apify.mdmarkdown1.8 KB
provider-playbooks/attention.mdmarkdown449 B
provider-playbooks/attio.mdmarkdown5.6 KB
provider-playbooks/aviato.mdmarkdown756 B
provider-playbooks/bettercontact.mdmarkdown1.7 KB
provider-playbooks/bigquery.mdmarkdown1019 B
provider-playbooks/bloomberry.mdmarkdown935 B
provider-playbooks/bluesky.mdmarkdown139 B
provider-playbooks/bounceban.mdmarkdown1.6 KB
provider-playbooks/brave.mdmarkdown422 B
provider-playbooks/browserbase.mdmarkdown1.0 KB
provider-playbooks/builtwith.mdmarkdown1.0 KB
provider-playbooks/buyercaddy.mdmarkdown2.3 KB
provider-playbooks/cbinsights.mdmarkdown436 B
provider-playbooks/clay.mdmarkdown875 B
provider-playbooks/clickhouse.mdmarkdown1.1 KB
provider-playbooks/close.mdmarkdown2.6 KB
provider-playbooks/cloudflare.mdmarkdown2.3 KB
provider-playbooks/contactout.mdmarkdown8.3 KB
provider-playbooks/contextdev.mdmarkdown582 B
provider-playbooks/crunchbase.mdmarkdown742 B
provider-playbooks/crustdata-v2.mdmarkdown490 B
provider-playbooks/crustdata-v3.mdmarkdown8.4 KB
provider-playbooks/crustdata.mdmarkdown6.8 KB
provider-playbooks/databricks.mdmarkdown3.5 KB
provider-playbooks/dataforseo.mdmarkdown950 B
provider-playbooks/datagma.mdmarkdown6.0 KB
provider-playbooks/dealroom.mdmarkdown632 B
provider-playbooks/deepline-ip-to-company.mdmarkdown480 B
provider-playbooks/deepline-native-osint.mdmarkdown1.5 KB
provider-playbooks/deepline-native.mdmarkdown25.1 KB
provider-playbooks/deeplineagent.mdmarkdown2.7 KB
provider-playbooks/deepseek.mdmarkdown1.2 KB
provider-playbooks/discolike.mdmarkdown6.2 KB
provider-playbooks/dnb.mdmarkdown1.4 KB
provider-playbooks/dropleads.mdmarkdown10.2 KB
provider-playbooks/edges.mdmarkdown875 B
provider-playbooks/emailbison.mdmarkdown634 B
provider-playbooks/emailguard.mdmarkdown243 B
provider-playbooks/enformion.mdmarkdown9.3 KB
provider-playbooks/enigma.mdmarkdown1.7 KB
provider-playbooks/exa.mdmarkdown1.4 KB
provider-playbooks/file-transport.mdmarkdown739 B
provider-playbooks/findymail.mdmarkdown880 B
provider-playbooks/firecrawl.mdmarkdown2.4 KB
provider-playbooks/fireflies.mdmarkdown988 B
provider-playbooks/firmable.mdmarkdown1.3 KB
provider-playbooks/forager.mdmarkdown2.3 KB
provider-playbooks/fullenrich.mdmarkdown2.1 KB
provider-playbooks/fundable.mdmarkdown2.0 KB
provider-playbooks/generic-http.mdmarkdown348 B
provider-playbooks/getleads.mdmarkdown2.2 KB
provider-playbooks/gong.mdmarkdown488 B
provider-playbooks/google-ads-audiences.mdmarkdown2.0 KB
provider-playbooks/google-calendar-availability.mdmarkdown1.6 KB
provider-playbooks/google-calendar.mdmarkdown1.1 KB
provider-playbooks/google-sheets.mdmarkdown842 B
provider-playbooks/google-workspace.mdmarkdown2.1 KB
provider-playbooks/govfiles.mdmarkdown1.8 KB
provider-playbooks/grain.mdmarkdown1.0 KB
provider-playbooks/hackernews.mdmarkdown208 B
provider-playbooks/harvestapi.mdmarkdown3.5 KB
provider-playbooks/heyreach.mdmarkdown1.6 KB
provider-playbooks/hubspot.mdmarkdown3.3 KB
provider-playbooks/hunter.mdmarkdown849 B
provider-playbooks/icypeas.mdmarkdown1.8 KB
provider-playbooks/instantly.mdmarkdown1.6 KB
provider-playbooks/integration-operation.mdmarkdown704 B
provider-playbooks/intercom.mdmarkdown275 B
provider-playbooks/ipqs.mdmarkdown1.7 KB
provider-playbooks/kaspr.mdmarkdown822 B
provider-playbooks/kernel.mdmarkdown875 B
provider-playbooks/leadmagic.mdmarkdown5.3 KB
provider-playbooks/lemlist.mdmarkdown7.5 KB
provider-playbooks/limadata.mdmarkdown636 B
provider-playbooks/linkedin-ads-audiences.mdmarkdown629 B
provider-playbooks/luma.mdmarkdown3.2 KB
provider-playbooks/lusha.mdmarkdown3.5 KB
provider-playbooks/meerapi.mdmarkdown1.2 KB
provider-playbooks/meta-audiences.mdmarkdown4.8 KB
provider-playbooks/millionverifier.mdmarkdown618 B
provider-playbooks/nooks.mdmarkdown1.0 KB
provider-playbooks/notion.mdmarkdown724 B
provider-playbooks/openmart.mdmarkdown2.3 KB
provider-playbooks/opensosdata.mdmarkdown4.0 KB
provider-playbooks/openwebninja.mdmarkdown315 B
provider-playbooks/outreach.mdmarkdown2.6 KB
provider-playbooks/parallel.mdmarkdown4.4 KB
provider-playbooks/particle.mdmarkdown2.0 KB
provider-playbooks/peopledatalabs.mdmarkdown4.5 KB
provider-playbooks/pipedrive.mdmarkdown582 B
provider-playbooks/pitchbook.mdmarkdown606 B
provider-playbooks/podscan.mdmarkdown2.7 KB
provider-playbooks/polymarket.mdmarkdown2.2 KB
provider-playbooks/postgres.mdmarkdown553 B
provider-playbooks/predictleads.mdmarkdown622 B
provider-playbooks/prospeo.mdmarkdown2.4 KB
provider-playbooks/quickenrich.mdmarkdown595 B
provider-playbooks/rapidapi.mdmarkdown2.5 KB
provider-playbooks/rb2b.mdmarkdown247 B
provider-playbooks/redshift.mdmarkdown763 B
provider-playbooks/reo-write.mdmarkdown1.6 KB
provider-playbooks/reo.mdmarkdown2.0 KB
provider-playbooks/resend.mdmarkdown3.6 KB
provider-playbooks/salesforce.mdmarkdown3.6 KB
provider-playbooks/salesforge.mdmarkdown274 B
provider-playbooks/salesloft.mdmarkdown1.0 KB
provider-playbooks/scrapecreators.mdmarkdown3.4 KB
provider-playbooks/searchbug.mdmarkdown637 B
provider-playbooks/sec-edgar.mdmarkdown1.6 KB
provider-playbooks/sentrion.mdmarkdown737 B
provider-playbooks/serper.mdmarkdown1011 B
provider-playbooks/slack.mdmarkdown21.1 KB
provider-playbooks/smartleads.mdmarkdown11.8 KB
provider-playbooks/snitcher.mdmarkdown302 B
provider-playbooks/snowflake.mdmarkdown768 B
provider-playbooks/socrata.mdmarkdown3.2 KB
provider-playbooks/sumble.mdmarkdown1.3 KB
provider-playbooks/tamradar.mdmarkdown1.4 KB
provider-playbooks/test-unhinted.mdmarkdown505 B
provider-playbooks/test.mdmarkdown254 B
provider-playbooks/theirstack.mdmarkdown4.4 KB
provider-playbooks/theswarm.mdmarkdown1.4 KB
provider-playbooks/treg.mdmarkdown1.5 KB
provider-playbooks/trestle.mdmarkdown3.7 KB
provider-playbooks/trykitt.mdmarkdown862 B
provider-playbooks/twitterapi.mdmarkdown3.6 KB
provider-playbooks/unipile.mdmarkdown4.8 KB
provider-playbooks/upcell.mdmarkdown715 B
provider-playbooks/vector.mdmarkdown257 B
provider-playbooks/versium.mdmarkdown690 B
provider-playbooks/wiza.mdmarkdown2.0 KB
provider-playbooks/wizleads.mdmarkdown1.1 KB
provider-playbooks/zerobounce.mdmarkdown1.3 KB
provider-playbooks/zoho-crm.mdmarkdown630 B
provider-playbooks/zoominfo.mdmarkdown1.2 KB
recipes/account-orgchart.mdmarkdown35.6 KB
recipes/build-tam.mdmarkdown3.7 KB
recipes/clay-to-deepline.mdmarkdown26.8 KB
recipes/deepline-monitors.mdmarkdown32.5 KB
recipes/developer-signals.mdmarkdown14.7 KB
recipes/find-qualified-titles.mdmarkdown5.2 KB
recipes/portfolio-prospecting.mdmarkdown3.6 KB
recipes/small-business-prospecting.mdmarkdown3.0 KB
references/clay-action-mappings.mdmarkdown40.0 KB
references/clay-api-surface.mdmarkdown18.6 KB
references/clay-extraction.mdmarkdown16.2 KB
references/industry-radars.mdmarkdown3.3 KB
references/monitor-contract-reference.mdmarkdown25.9 KB
references/monitor-operations.mdmarkdown12.4 KB
references/monitor-sdk.mdmarkdown3.2 KB
references/run-events.mdmarkdown14.3 KB
scripts/clay-extract-bookmarklet.jsscript10.5 KB
scripts/clay-extract-bookmarklet.url.txtmarkdown8.2 KB
scripts/clay-extract.pyscript17.9 KB
scripts/clay-har-miner.pyscript5.8 KB
scripts/clay-to-deepline.mjsscript134.1 KB
scripts/contact-accuracy-audit.pyscript8.9 KB
scripts/fixtures_contact_accuracy_audit.jsonconfig5.5 KB
scripts/fixtures_current_role.jsonconfig10.3 KB
scripts/flatten-search-contact-persons.pyscript3.3 KB
scripts/select-current-role.pyscript12.2 KB
scripts/validate-emails.pyexecutablescript2.0 KB
skill-metadata.jsonconfig2.2 KB
writing-outreach.mdmarkdown14.1 KB

recipes/clay-to-deepline.md

View on GitHub
---
name: clay-to-deepline
description: 'Move Clay tables, workflows, functions and Signals to Deepline Plays and Monitors, and compare what the same run costs in Clay and in Deepline. Use for any Clay migration, Clay export or bookmarklet JSON, Clay CLI workspace, "convert this Clay table", Clay credit cost, or "is Deepline cheaper than Clay". Reads a Clay CLI export or a bookmarklet / clay-extract.py JSON file. Makes the Plays, proves formula parity on real rows, and prices both sides.'
---

# Clay to Deepline

<!-- skill-tool-field: match -- Cell-parity result status, not a tool alias. -->
<!-- skill-tool-field: clay_not_evaluated -- Cell-parity status for a Clay cell that has not run. -->
<!-- skill-tool-field: clay_stale_input -- Cell-parity status for changed source inputs. -->
<!-- skill-tool-field: clay_stale -- Cell-parity status for stale source results. -->
<!-- skill-tool-field: clay_error -- Cell-parity status for a failed source cell. -->

Convert Clay tables to Deepline Plays. Make one `withColumn` for each Clay column.
Prove that the formulas give the same values as Clay. Then compare the cost of
the Clay run with the cost of the Deepline run.

For run authority, pilots, and result retrieval, use [build, run and retrieve](../SKILL.md).

## 1. Choose the input

Two inputs give the same result. Each makes one export folder (`<dir>`). Every later command reads that folder.

| You have                                            | Command                         | Notes                                                                                           |
| --------------------------------------------------- | ------------------------------- | ----------------------------------------------------------------------------------------------- |
| The Clay CLI (`clay`), logged in                    | `export <dir>`                  | Best input. Reads the whole workspace. Does not need a browser cookie. Read-only.               |
| A bookmarklet or `clay-extract.py` JSON (one table) | `import <dir> <file-or-folder>` | Use when the user has no Clay CLI. Read [clay-extraction.md](../references/clay-extraction.md). |
| A HAR file, or only a description of the table      | none                            | No command reads these. Use section 9, and mark every claim `config-inferred, unvalidated`.     |

The bookmarklet keeps display values. It does not keep structured `fields` for most actions.
Parity is weaker for formulas that read those actions. `import` prints a warning when this applies.

## 2. Commands

Set `S` to the script in this skill folder. Node 18 or later. No npm packages.

```bash
S=<this skill>/scripts/clay-to-deepline.mjs
node $S export  <dir> --rows 25                  # Clay CLI: tables, columns, functions, 25 full rows per table
node $S import  <dir> extract.json [more.json]   # bookmarklet / clay-extract.py JSON, or a folder of them
node $S compile <dir>                            # plays/*.play.ts, *.clay.js, seeds/*.csv, migration-report.json, keys.json
node $S parity  <dir>                            # each formula and lookup cell against Clay's stored value; exit 1 on a mismatch
node $S check   <dir>                            # deepline plays check on every play (free, no run)
node $S cost    <dir> [--plan launch|growth|legacy] [--pricing file.json]   # Clay cost and Deepline cost, per column
node $S workflow-cost <dir> wf_xxx [--limit 50] # Clay-metered credits for each completed workflow run
node $S sample  <dir> --table t_x --column "Work Email" --row-ids r_a,r_b   # one column and its inputs as a pilot play
node $S signals <dir> [--signals td_a,td_b]      # Clay Signals to Monitor Fleet drafts and a gap report. See section 9.
node $S selftest                                 # Clay-semantics assertions, no network
```

- Add `--tables t_a,t_b` to `export` for a subset of tables.
- Run `compile` and `check` from a folder pinned to the target Deepline workspace.
  `compile` reads tool schemas with `deepline describe`. `check` validates credentials there.
- `import` and `export` can write to the same `<dir>`. The tables add up.
- No command in this list runs a paid Deepline call. `sample` only writes a play.

## 3. Output files

| File                                             | Use                                                                                                                                                                                                                                                                  |
| ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `plays/<table>.play.ts`                          | One play for each Clay table. Formula columns are local `withColumn`s. Actions are tool calls. Run conditions are `runIf`. Columns are in dependency order.                                                                                                          |
| `plays/<table>.clay.js`, `plays/clay-runtime.js` | Clay formulas and Clay semantics as plain JS. The play and `parity` import the same files. The parity result is about the code that the play runs.                                                                                                                   |
| `seeds/<table>.csv`                              | The input columns of the exported rows. Use it as a pilot CSV.                                                                                                                                                                                                       |
| `migration-report.json`                          | Each column with `kind` (seed, formula, local, lookup, waterfall, action) and `status` (compiled, mapped, needs_review, unmapped). Also the mapped tool and provider, `substitute`, `sameCapability`, `resolveTool`, `reuses`, and the reason a column needs review. |
| `keys.json`                                      | One row for each Deepline provider: `required`, `optional` or `managed`. Also whether Clay used the user's own key, and the `deepline tools connect` command.                                                                                                        |
| `parity-cells.csv`, `parity-columns.json`        | The parity verdict for each cell and each column. Show these to the user.                                                                                                                                                                                            |
| `billing.json`                                   | Written by `export`. Records whether the workspace is on an action-execution plan. `cost` reads it to choose the plan.                                                                                                                                               |
| `workflow-cost-<id>.json`                        | Written by `workflow-cost`. Clay-metered credits for each run.                                                                                                                                                                                                       |
| `cost-report.json`, `cost-columns.csv`           | Cost for each action column: Clay, Deepline, and the source of each number. See section 5.                                                                                                                                                                           |

## 4. Keys

`export` records the connection that each Clay action used: the workspace's own key, or the Clay shared key.
`compile` writes `keys.json`. Before any run, show this table to the user and ask the user to connect:

- Each `deeplineKey: required` provider (CRMs, sequencers: HubSpot, Salesforce, HeyReach). Deepline has no managed access for them. Their plays fail until connected.
- Each `optional` provider where `clayKeys` includes `own`. The user paid that vendor directly in Clay. The user keeps that contract and rate in Deepline.
- An `optional` provider that ran on a Clay-managed key runs on Deepline credits. A key is optional.

The user connects each provider with `deepline tools connect <provider>` (owner or admin; OAuth opens a browser),
or at the `setupUrl` in `keys.json`. Suggest `! deepline tools connect <provider>` so that it runs in the user's session.
Never ask for a key in chat. Never connect a key yourself. Run `check` again after the user connects.

## 5. Compare cost: Clay and Deepline

Run `cost <dir>` after `compile`. Without `compile`, the Deepline side is empty.
The command reads the completed Clay rows in `<dir>`. It does not start any Clay or Deepline run.

**How each number is found**

| Number                      | Source                                                                                                                                                                                               |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Clay credits, from metadata | A credit key inside a cell `metadata` object. This is Clay's own record. When it exists, the command uses it (`claySource: metadata`).                                                               |
| Clay credits, from catalog  | If no metadata credit exists, the command uses the public Clay price catalog (`claySource: catalog`): data credits plus action credits, and the USD for each run on the chosen plan.                 |
| Vendor-reported credits     | A credit key inside `fields` (`credits_consumed`, `creditBurn`). The vendor wrote it. Clay did not bill this number. The command reports it as `vendorReportedAvg` and does not use it for Clay USD. |
| Deepline cost               | The mapped tool in `migration-report.json`, priced by `deepline describe` ("credits / $ per result").                                                                                                |

**Choose the plan**

The Clay CLI does not return the plan name or tier. Use this order:

1. The `--plan` flag, when the user states the plan.
2. `billing.json`. If `actionExecutionBalance` was absent, the workspace is on the legacy plan, and `cost` uses `legacy`.
   If it was present, the workspace is on an action-execution plan. The tier is unknown, so `cost` uses `growth`.
3. With no `billing.json` (for example after `import`), `cost` uses `growth`.

`cost-report.json` shows `planSource`. When the tier is unknown, ask the user for the tier. Do not guess it.

**Workflows have measured credits**

A table cell has no Clay billing field. A workflow run does.
`clay workflows runs get <runId>` returns `dataCreditsUsed` and `actionCreditsUsed`.
Run `workflow-cost <dir> wf_xxx` to total them over the completed runs.
These numbers are Clay's own metering (`source: metadata`). The totals are final only when a run is complete.
To see spend over a period for the whole workspace, run
`clay workflows analysis aggregate --input '{"groupBy":["workflow","day"]}'`.
This needs run analysis to be enabled for the workspace.

**Rules**

1. Say which source gave each Clay number. A catalog price is a plan estimate. A metadata number is a measured charge.
2. Do not call a vendor credit a Clay charge. The exported CLI cell has only `status`, `value` and `fields`. It has no Clay billing field. A bookmarklet cell can have `metadata`. Check one cell before you promise measured Clay cost. For a workflow, use `workflow-cost`.
3. Report `pricedBothSides` and `unpricedColumns`. AI columns, CRM writes, and unmapped actions have no fixed Deepline price. Do not add them to a total as zero.
4. The result is for the exported sample, scaled to the source row count of each table. State the sample size.
5. A tool priced "per result" bills a hit only. Clay can bill a miss. Treat the Deepline number as an upper bound for those columns.
6. Clay USD comes from a point-in-time catalog (`catalogUpdatedAt`). It is a plan estimate. It excludes plan fees and seats. Say this.
7. For a measured check, use `clay credits balance` before and after one pilot run. Other runs in the workspace change the balance. Use this only on a quiet workspace.

The public catalog is `https://code.deepline.com/api/public/gtm-data-pricing/clay-actions/export`.
Pass `--pricing <file>` to use a saved copy when the network is closed.

**Answer format.** Give a short table for the user: the five columns with the largest Clay cost, then the totals.

| Column | Clay action | Clay USD (source) | Deepline tool | Deepline USD | Note |
| ------ | ----------- | ----------------- | ------------- | ------------ | ---- |

After the table, give the total for the columns priced on both sides, the number of unpriced columns, and the sample size.

## 6. Clay semantics that the compiler reproduces

Each rule below was a parity failure on a real workspace. `parity` now covers each one.

- A Clay formula is a JavaScript expression. It is not a template. A raw newline inside a string literal is legal in Clay. The compiler escapes it.
- `{{column}}` on an action or source column reads its structured `fields`. Its `value` is only a display string, for example "No Record Found". A column with no `fields` reads as empty.
- `{{column}}?.a?.["b"]` resolves as one path lookup. A missing column or path is `''`. It is never `"undefined"`.
- Clay stores output as trimmed text, then types it with the column data type. A `url` or `email` that fails validation becomes empty. A `date` becomes ISO UTC. Text over about 8 KB becomes empty.
- `Clay.formatForJSON(x)` escapes text for use inside a JSON string that already has quotes.
- `moment` and lodash calls run on a small UTC subset: `format`, `isSame`, `isSameOrAfter`, `diff`, `toISOString`, `_.uniq`, `_.keys`. If the report shows another helper, add it to `clay-runtime.js`.
- `lookup-row-in-other-table` returns the first match in creation order as `{ record }`. `lookup-multiple-rows` returns `{ records, numberOfResults }`. The play takes the target table as a CSV input, `lookup_<tableId>`, with Clay column names as headers. Clay's own CSV export has this shape.

## 7. Waterfalls

A Clay waterfall is a merge column (`formulaType: waterfall`) over N provider columns.
Each provider column has a run condition. The condition skips the column when an earlier step found a validated value.
The compiler keeps this. The merge becomes `__clay.waterfall(step1, step2, ...)`. Each provider column keeps its own `runIf`.

How the compiler maps a vendor:

- **Same vendor, if Deepline has it.** Findymail stays Findymail. `find-email-v2` is Hunter. `validate-email` is ZeroBounce. `enrich-person` is PDL. The vendor comes from the connection type, not from the action key.
- **Same capability.** Clay's `google-company-to-domain` is the same Google search on Serper (`serper_google_search`). The report marks it `sameCapability`.
- **Two-step id lookup.** Dealroom and Crunchbase take their own entity ids. The column first searches by company domain, then calls the funding tool on the id. A call is skipped when its input is empty. Both vendors need the user's own key.
- **Vendor that Deepline does not have.** The compiler picks a substitute from an ordered pool. The pool skips providers that the table already uses. An identical call reuses the result of the earlier column. A waterfall `note` says when Deepline has fewer distinct providers than Clay.
- **Clay field names.** Clay formulas read Clay field names (`{{finder}}?.email`). A provider column is read through `__clay.view`. It finds the first non-null field with that name in the Deepline response. Without it, every gate reads empty and every step runs.
- **Empty input.** A tool call with an empty required input is skipped, as in Clay.

Pilot one waterfall with `sample`. Run it with `--max-credits`. Compare each row's step trace with the step that Clay hit.
Clay's stored hits can be months old. A same-vendor miss today is a data difference, not a mapping error.
Check that no later step ran after a validated hit.

## 8. Read `parity`

`parity` rebuilds each row from Clay's input cells. It compares each formula cell with the value that Clay stored.
A clean run shows `mismatch: 0`. Report the other verdicts as counts. Never report them as matches.

| Verdict                           | Meaning                                                                                                                      |
| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `match`                           | Same value. For a formula that reads the current time, "same" means both are empty or both are not empty. Count these apart. |
| `clay_not_evaluated`              | Clay never computed the cell (status `empty`). The play computes it.                                                         |
| `clay_stale_input` / `clay_stale` | An input is empty or stale. Clay's value is older than its inputs.                                                           |
| `dangling_ref`                    | The formula reads a deleted Clay column. Fix the formula in Clay or in the play.                                             |
| `clay_error`                      | Clay gave an error. The play made no value.                                                                                  |
| `not_in_sample`                   | Lookup only. Clay's matched row is not in the exported sample. Raise `--rows`.                                               |
| `target_changed_later`            | Lookup only. The target row or column is newer than this row. Clay does not re-run a lookup when its target changes.         |

`parity` covers formula, local, lookup and waterfall-merge columns. These are deterministic. They must match 100%.
Provider columns and AI columns return live data. Validate them on a paid pilot (`sample`, then section 11).
A formula that reads a provider output path is `config-inferred` until a pilot shows that the path resolves on a Deepline response.
A substitute vendor can change the response shape more than a same vendor does.

## 9. Work the compiler does not do

**Manual columns.** The compiler writes a column that throws, with the reason. A run fails loudly. It does not skip.
These actions are manual: `route-row`, `write-to-other-table-v2`, `trigger-find-people-source`, `lookup-company-in-other-table`, Google Docs writes, and Google Sheet upserts.
For `route-row`, write one filtered output CSV for each destination.

**Clay Functions.** A function table has a "Function inputs" source field (`f_subroutine_source`) and a `write-to-cell` action.
The compiler lists each function with its inputs and actions. It does not compile it. `clay functions get` returns an XML schema with action display names. It does not return action keys.
Port each function as one reusable play:

1. Make the play input from `SUBROUTINE_INPUTS`. If `tableSettings` is missing, use the distinct `{{f_subroutine_source}}?.["..."]` keys.
2. Add one `withColumn` for each field that is not a source and not `write-to-cell`. Keep dependency order.
3. Make the output from the `write-to-cell` `data` `formulaMap`. Do not build a `write-to-cell` column.

See the Functions section of [clay-extraction.md](../references/clay-extraction.md).

**Triggers and routing.** A table with a webhook trigger, a CRM write, or a campaign push needs a play with triggers.
Run `deepline plays --help`. Use the extracted config as the source.

**Clay Signals.** `signals <dir>` reads each Signal and its watched rows. It writes `signals/report.json`, one `signals/fleets/*.fleet.json` for each convertible Signal, `signals/seeds/*.sql`, and `signals/rows/*.csv`, which holds every source column for each seeded row. It is read-only against Clay and deploys nothing. Use a new `<dir>` for each export. The command refuses to reuse one.

Show the report to the user first. Each Signal is `drafted`, `skipped` or `blocked`. `unmapped` lists Clay settings with no monitor input. A filter moved to the Play does not reduce the findings you pay for.

Then, after approval:

1. Run each seed file, in order, with `deepline db query --sql @<file>`. The create file fails if the table exists. Inserts cannot remove or correct a target, so reconcile a re-export by hand.
2. The Clay CLI cannot read a view, so the seed holds the whole table. Use `signals/rows/<table>.csv` to find the rows outside the view, then delete their `row_key` from the seed table. Keep a `row_key` if any row in the view shares it.
3. Run `deepline monitors fleets deploy --file <fleet> --dry-run`. Show the plan. Deploy only after approval.
4. Add a Play with a `sqlListeners` trigger. Anything that read Clay's event table reads the monitor's table instead.
5. Run both sides until they agree. Pause the Clay Signal with `clay signals pause`. Do not delete it.

Topic intent, Custom, web intent and audience-based Signals are not converted. `monitors preview` supports only `company_new_hires`, so job-opening volume cannot be sampled before deploying. Roll out a small Fleet first.

**Unknown action.** Do not guess from the action name. Use this order:

1. The job-based table in [clay-api-surface.md](../references/clay-api-surface.md#map-by-job-not-by-provider-name). It covers about 85% of real usage.
2. The payload reference [clay-action-mappings.md](../references/clay-action-mappings.md). It has no phone or CRM rows. Verify each tool id.
3. The Clay action catalog in `clay-api-surface.md`, for the real input schema.
4. `deepline search "<input you have -> result you need>"`, then `deepline describe <tool>`.
5. If no tool fits, use `deeplineagent` with a `jsonSchema`.

Common mappings: email waterfall with `validate-email` is `name-and-domain-to-email-waterfall`. A phone column is `prebuilt/person-to-phone`; it needs a name and a domain, but many Clay finders need only a LinkedIn URL.
`use-ai` without web is `deeplineagent`. `chat-gpt-schema-mapper` is `deeplineagent` with `jsonSchema`.
A campaign push is `instantly_add_to_campaign` or `smartlead_push_to_campaign`.
A column with `enrich-person` as the key is often wired as a phone or email finder. Read `inputsBinding` first.

**Web research columns (`use-ai` with claygent).** Use two columns: `exa_search` for retrieval and `deeplineagent` for synthesis.
Add `research_confidence` and `research_passes` columns. Add the domain to every query. Quote the company name.
Judge the result by content, not by the confidence label. Count markers such as `UNCHANGED`, `UNRESOLVED` and `Unable to determine` as failed research.

**Prompts.** Use Clay's exact prompt text. A small change causes drift. Recover it in this order, and mark the source in the play:

1. HAR: `bulk-fetch-records` cell values have the rendered prompt.
2. Extract: `fields[].typeSettings.inputsBinding[name=prompt].formulaText` (`RECOVERED FROM EXTRACT`).
3. ClayMate `portableSchema` (`RECOVERED FROM PORTABLE SCHEMA`).
4. Approximation from outputs (`APPROXIMATED`).

In a recovered prompt, change `{{@Name}}` to `{{name}}`. Remove the `Clay.formatForAIPrompt(...)` wrapper. A single-brace `{name}` is not filled in by Deepline.

**No cell data.** Some extracts have config only. You cannot check the cell values of three or more records.
Infer the pipeline from `actionKey`, `conditionalRunFormulaText` and `formulaWaterfall`.
Mark every architecture and parity claim `config-inferred, unvalidated`. Do not decide anything that needs real cell values.

## 10. Rules

- Declaration order is execution order. Put local transforms before the paid columns that read them.
- Gate each expensive column with `runIf`. Do not pay for a row that a cheaper column already answered.
- A column reference is `row.alias`. A Clay path `{{a.items[0].b}}` becomes a typed read with explicit missing-value handling. TypeScript does not fill in braces.
- Use one `deeplineagent` call for each AI column. Put all fields in one `jsonSchema`.
- Accept `valid`, `valid_catch_all` and `catch_all` from email validation. Do not accept `unknown`.
- Never put a Clay cookie in a play or in a payload.
- A rerun is not free. A tool receipt is reused only when the tool and the input are the same. Do not promise a free rerun.

## 11. Validate and run

Thresholds:

| Column type                                 | Threshold                                                 |
| ------------------------------------------- | --------------------------------------------------------- |
| Formula, local, lookup, waterfall merge     | 100% match (`parity`, `mismatch: 0`)                      |
| LLM classification                          | 90% or more exact match on clear cases                    |
| LLM generation                              | Tone and intent match (manual review)                     |
| Structured (`deeplineagent` + `jsonSchema`) | All schema fields filled in 100% of rows                  |
| Email (`work_email`)                        | Deepline found rate is 95% or more of the Clay found rate |
| Web research                                | Failed research on 15% of rows or fewer                   |

For provider and AI columns, run a pilot. Then export it and compare each column with the same Clay rows:

```bash
node $S check  <dir>                                                               # step 1: compile only, no spend
deepline run <dir>/plays/<table>.play.ts --input '{"csv":"<dir>/seeds/<table>.csv"}' --max-credits <cap>   # step 2: pilot rows
deepline runs export <run-id> --out pilot.csv
deepline csv show pilot.csv --summary                                               # fill rate for each column
```

Join the pilot to Clay's cells (`rows/<tableId>/<rowId>.json`, `value` and `fields`) on the seed columns.
Report found rate and agreement for each column.

If a mismatch appears, check these in order: prompt parity, model parity, true ambiguity (run it three times). Then write it down. Do not tune the play to one row.

Authority and spend:

- Planning, `compile`, `parity`, `check` and `cost` permit no paid run.
- Start a paid pilot only with the user's approval of the scope and the cap. State the row count and the credit estimate.
- After a good pilot, run the rest of the approved scope. Ask again only if scope, cost or risk changes.
- `deepline plays check` calls the Deepline compile API. It needs auth and network.

## 12. Checklist

1. Choose the input (section 1). Run `export` or `import`.
2. Run `compile`, `parity` and `check`. Show the user the parity counts, `keys.json`, and the columns that need review.
3. Get the user's approval for the scope and the cap.
4. Run one pilot. Compare the provider and AI columns with Clay.
5. Run `cost`. Show the comparison table from section 5, with the source of each number.
6. Run the approved scope. Report coverage, spend, and the columns that stayed manual.
deprecation-and-migrationaddyosmani/agent-skillsManages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when migrating a database schema in production, such as renaming or dropping a column without downtime (expand/contract). Use when deciding whether to maintain or sunset existing code.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
performance-optimizationaddyosmani/agent-skillsOptimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
agent-cost-reportthedotmack/claude-memBelievable agent cost report for any period, default the last 7 full days PT, not counting today. Measured tokens from Claude Code transcripts priced at OpenRouter list prices (ESTIMATED), measured provider spend when a sanctioned source exists, note-taker cost separate, Timing-style HTML/PDF plus report.json, line-items.csv, evidence.json.Stars: 118kUpdated Claude CodeCodexVerifiedInstall