# Clone Instructions: Account Health Autopilot (Weekly Customer Health Scoring in Your CRM)

> **For the clone.** Your user has handed you this file. Follow it step by step.
> **Version 1.1.0 · Last updated 2026-10-22**

---

## 1. Role and goal

You are setting up the **Account Health Autopilot** use case for your user.

When setup is done, every week at `{RUN_TIME}` you will run a skill called **Account Health Autopilot** that:

1. builds the list of in-scope accounts or opportunities (`{ACCOUNT_SCOPE}`), applying `{NAME_MAPPINGS}` and `{EXCLUSIONS}`,
2. sweeps the previous 7 days across four sources: call transcripts, email, the CRM support signal (Salesforce Cases, or HubSpot notes/tasks/engagements) and the Linear tracker,
3. reports every source as "results", "no results" or "lookup failed", and verifies keyword hits by reading them,
4. grades each account on a 6-level health scale (`{HEALTH_SCALE}`),
5. drafts updates to three CRM fields: `{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}` and `{INTEGRATIONS_NEEDED_FIELD}`,
6. shows the full proposed changes and waits for approval,
7. writes approved changes in small batches to `{WRITE_TARGET}` records,
8. sends a weekly report to `{REPORT_RECIPIENTS}` and/or `{TEAM_CHANNEL}`.

Your job right now is **setup only**: discover what's available, check whether the three CRM fields exist, collect the user's settings, propose a plan, do the parts you're able to do after approval, and clearly hand over the parts only the user can do.

**Tools for this use case:** CRM is Salesforce (`SalesforceAccountOperator`, `SalesforceOpportunityOperator`, `SalesforceCaseOperator`, `SalesforceActivityOperator`) or HubSpot (`HubspotCompanyOperator`, `HubspotDealOperator`, `HubspotEngagementOperator`). HubSpot has no tickets/cases operator, so the support signal comes from notes, tasks and engagements. Tracker is Linear (`Linear_Operator`). Email is Gmail (`GoogleGmailOperator`) or Outlook. Transcripts come from a `GoogleDriveCoreOperator` or `Microsoft_OneDrive` folder, or `meeting_archive` (plus `call_archive` for phone calls). The report goes by email and/or Slack or Teams. Custom fields can only be created in Salesforce or HubSpot. If the user's tools are not on this list, say so plainly instead of improvising.

**Quick-start alternative:** the prebuilt skill **Weekly-Account-Health-Update** exists. Mention it to the user: it can be attached via the `platform` tool for a faster start, while the custom skill in section 7 gives full control. Continue with this card unless the user prefers the prebuilt skill.

Be honest about your limits. If a tool isn't available to you, you lack a permission, or a step fails, say so plainly and give the user the exact manual steps instead.

## 2. Safety rules (read before doing anything)

- **Plan first, then act.** Before you attach, create, schedule or change anything, show the user a numbered plan and wait for an explicit "yes". No yes = no changes.
- **Approval is per plan.** If the plan changes, show the new plan and ask again.
- **Never ask for, accept or handle passwords, API keys or tokens.** All connections are made by the user through the platform's own sign-in (OAuth) screens. If the user pastes a secret into chat, tell them not to and don't use it.
- **Never email customers during setup.** The only messages you may send during setup are a test report to the user (and only after they approve it).
- **No CRM writes during setup.** During setup you only read from the CRM, ticket tracker, email and file storage. The one exception is creating the three custom fields, and only if the user approves that specific step and your CRM operator has the rights to do it. Never edit customer records during setup; the test plan uses a dry run and a test record.
- **Read-only everywhere except the three fields.** The finished skill reads from email, transcripts, cases and the tracker, and writes only the three named fields on `{WRITE_TARGET}` records, only after approval.
- **Don't guess names.** Use exact skill/operator names as they appear in the user's skill catalog, and exact CRM field names and picklist values.

## 3. Discovery

Check what you already have. Use the platform tool to list your attached skills/operators and connections, and use `describeOperator` on each relevant operator to confirm what it can do (read, write, search, create fields) and whether its connection is active.

Look for:

| Need | Required? | Examples of what to look for |
|---|---|---|
| CRM operators | **Required** (read + write) | Salesforce: `SalesforceAccountOperator`, `SalesforceOpportunityOperator`, `SalesforceCaseOperator`, `SalesforceActivityOperator`. HubSpot: `HubspotCompanyOperator`, `HubspotDealOperator`, `HubspotEngagementOperator` |
| Email connection | **Required** | `GoogleGmailOperator` or Outlook (read + send) |
| Transcript source | **Required** | `GoogleDriveCoreOperator` or `Microsoft_OneDrive` access to `{TRANSCRIPTS_FOLDER}`, or `meeting_archive` (plus `call_archive` for phone calls) |
| Scheduled task | **Required** | Ability to create a recurring scheduled task |
| Issue tracker | Optional (strongly recommended) | `Linear_Operator` |
| Messaging | Optional | Slack or Microsoft Teams (to post the report to `{TEAM_CHANNEL}`) |
| Product usage export | Optional | A usage sheet in `GoogleSheets-Operator` or `Microsoft_Excel` (helps spot silent risk) |

Then, if the CRM is connected, check the CRM itself (read only):

- Do fields (Salesforce) or properties (HubSpot) matching `{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}` and `{INTEGRATIONS_NEEDED_FIELD}` already exist on the account or opportunity object? What are their types and picklist values?
- Can your CRM operator write to them (if `describeOperator` or a field-metadata lookup shows this)?
- Can your CRM operator create custom fields (admin/metadata rights)?
- Are there obvious required fields or validation rules on the object?

**Report the results to the user in a table like this:**

| Item | Status | Exact name in catalog | Notes |
|---|---|---|---|
| CRM operators (Salesforce or HubSpot) | ✅ Connected / ⚠️ Attached, not signed in / ❌ Missing | … | Read? Write? Create fields? |
| Email | … | … | … |
| Transcript source | … | … | Folder visible? |
| Scheduled task | … | … | … |
| Linear | … | … | … |
| Slack / Teams | … | … | … |
| Product usage data | … | … | … |
| Pain points field | ✅ Exists / ❌ Missing / ❓ | … | Type, length |
| Health field | … | … | Picklist values |
| Integrations needed field | … | … | Type |

If you can't check something (for example, there's no way to read field metadata), mark it "❓ Couldn't check" and say why.

## 4. Collect placeholder values

Ask the user **once**, in a single short list. Offer the examples. Don't proceed with the plan until you have answers (the user may say "use the default" where a default is given).

> To set this up I need a few details:
>
> 1. **Run time** (`{RUN_TIME}`): when should I run each week, with time zone? *(default: Monday 7:00 AM your time zone)*
> 2. **Your company domains** (`{YOUR_COMPANY_DOMAINS}`): e.g. `yourcompany.com, yourcompany.io`.
> 3. **Customer definition** (`{CUSTOMER_DEFINITION}`): how does your CRM mark a current customer? e.g. "Account Type = Customer AND Status = Active".
> 4. **Scope** (`{ACCOUNT_SCOPE}`): which accounts or opportunities should I grade? *(default: all current customers)*
> 5. **Write target** (`{WRITE_TARGET}`): put the three fields on the **account** or the **opportunity**? *(default: account)*
> 6. **Field names** (`{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}`, `{INTEGRATIONS_NEEDED_FIELD}`): existing field names, or should I help you create them? *(defaults: "Customer Pain Points", "Account Health", "Integrations Needed")*
> 7. **Health scale** (`{HEALTH_SCALE}`): use the default 6 levels (Bright Green, Green, Yellow, Orange, Red, Black) or your own?
> 8. **Transcripts** (`{TRANSCRIPTS_FOLDER}`): which Drive/OneDrive folder holds call transcripts, or should I use my own meeting archive?
> 9. **Name mappings** (`{NAME_MAPPINGS}`): aliases, product names and parent/child links, e.g. "Northwind = Northwind Traders Ltd". *(can start empty)*
> 10. **Exclusions** (`{EXCLUSIONS}`): records I must never grade, e.g. internal test accounts, referral partners.
> 11. **Required fields** (`{REQUIRED_FIELDS}`): fields a validation rule requires before a save, if you know them. *(I'll also look.)*
> 12. **Report** (`{REPORT_RECIPIENTS}` and/or `{TEAM_CHANNEL}`): who gets the approval request and weekly report?

I'll fill in `{CLONE_NAME}` and `{CLONE_INBOX}` from my own profile and show them in the table.

Repeat the answers back in a table and ask the user to confirm.

## 5. What you can do yourself (after approval)

Present a plan like this, filled in with real names from discovery:

> **Proposed plan (nothing changes until you say yes):**
> 1. Attach these missing skills/operators from the catalog: *[list exact names]*.
> 2. *(Only if fields are missing and my CRM operator has admin rights)* Create the three CRM fields on `{WRITE_TARGET}` exactly as specified below.
> 3. Create the **Account Health Autopilot** skill using the text in section 7, with your values filled in, **dry-run mode ON**.
> 4. Create a scheduled task "Weekly Account Health Autopilot" that runs the skill at `{RUN_TIME}`.
> 5. Run one dry run now and send you the test report (to you only). No CRM writes.
>
> **You'll need to do:** *[list from section 6]*.
>
> Reply **yes** to proceed, or tell me what to change.

After a clear "yes":

1. **Attach skills/operators.** Use the platform tool to search the catalog and attach each required/optional item the user approved (exact names from the table in section 3). Confirm each with `describeOperator`. If an item needs a sign-in, tell the user (it goes on their list).
2. **Create the three CRM fields (only if approved and missing).** Use these specs, adjusted to the user's CRM:

   | Field | Type | Values / limits | Help text |
   |---|---|---|---|
   | `{PAIN_POINTS_FIELD}` | Long text area (multi-line) | At least 2,000 characters (content kept under ~1,500) | "Updated weekly by {CLONE_NAME}. Most important fact first; upcoming changes in CAPS; quotes and case/ticket IDs." |
   | `{HEALTH_FIELD}` | Picklist (single select, dropdown) | Bright Green, Green, Yellow, Orange, Red, Black (or `{HEALTH_SCALE}`), in that order | "Weekly health grade. See the health scale definitions." |
   | `{INTEGRATIONS_NEEDED_FIELD}` | Long text area (or text, 255+) | Never blank; "None requested" if none | "Integration requests from the customer, with ticket IDs. Updated weekly." |

   If your CRM operator **can't create fields or lacks admin rights**, say so and give the user (or their CRM admin) the steps for their CRM (Salesforce or HubSpot). Menu names may differ slightly:
   - **Salesforce:** Setup → Object Manager → Account (or Opportunity) → Fields & Relationships → New → choose type (Text Area (Long) / Picklist) → enter label, length or values, help text → set field-level security (make it **visible and editable** for the integration user's profile or permission set) → add to page layout → Save.
   - **HubSpot:** Settings → Data Management → Properties → choose Company (or Deal) properties → Create property → choose field type (Multi-line text / Dropdown select) → add options for the picklist → Create. Check the clone's connected user or app can edit the property.
3. **Create the Account Health Autopilot skill.** Fill the placeholders with the confirmed values, keep **Dry-run mode: ON**, and save it.
   - **If you can't create a custom skill directly**, give the user the complete skill markdown in one copy-paste block, plus exact steps:
     1. Open your clone's settings → **Skills** (or **Custom skills**).
     2. Click **New skill** / **Add skill**.
     3. Name it exactly **Account Health Autopilot**.
     4. Paste the full block into the skill instructions field.
     5. Read it through, then **Save**.
     6. Tell me "saved" so I can verify it's attached.
     (Menu names may differ slightly in your workspace.)
4. **Create the scheduled task.** Name: "Weekly Account Health Autopilot". Schedule: `{RUN_TIME}`, weekly. Action: "Run the Account Health Autopilot skill for the previous 7 days." If you can't create scheduled tasks, give the user these exact values and steps to create it manually.
5. **Report back** what succeeded and what failed, honestly, with exact error messages.

## 6. What the user must do

Give the user this list, with the how-to steps, and track which ones are done.

1. **Sign in to connections (OAuth).** For each connection marked ⚠️ or ❌ (Salesforce or HubSpot, Gmail or Outlook, Drive or OneDrive, Linear, Slack or Teams): open the clone's **Connections** / **Integrations** page → choose the app → **Connect** / **Sign in** → approve the requested permissions. Minimum permissions: CRM read on accounts, contacts, opportunities and cases plus **edit on the three fields**; email read + send; file storage read; tracker read; chat post. *I can't do this for you and I never need your password.*
2. **Share the transcripts folder with me.** Share `{TRANSCRIPTS_FOLDER}` with `{CLONE_INBOX}` (view access is enough), including subfolders.
3. **Check field-level permissions in the CRM.** The CRM user or app I connect as must be able to **edit** `{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}` and `{INTEGRATIONS_NEEDED_FIELD}`. Being able to edit the record is not enough if the fields are locked. A CRM admin may need to do this.
4. **Create the three fields (if I couldn't).** Follow the steps in section 5, then tell me "fields created" and I'll verify them.
5. **Tell me about validation rules.** Ask your CRM admin which fields must be filled before an account (or opportunity) can be saved, and confirm `{REQUIRED_FIELDS}`. I'll never fill those in by guessing; blocked records go on the report.
6. **Review the first dry run with someone who knows the accounts.** Then tell me "turn off dry run" when you're happy.

## 7. The Account Health Autopilot skill (save this in full)

Fill in the placeholders, then save as a skill named **Account Health Autopilot**. Don't shorten it.

~~~~markdown
# Account Health Autopilot

## Purpose
Every week, review the previous 7 days of customer activity across call transcripts,
email, CRM support cases and the ticket tracker; grade each in-scope account's health;
draft updates to three CRM fields; get approval; write the approved changes; and send
a weekly report.

## Settings
- Clone name: {CLONE_NAME}
- Clone inbox: {CLONE_INBOX}
- Company domains (internal): {YOUR_COMPANY_DOMAINS}
- Run time: {RUN_TIME} (lookback: previous 7 days)
- Current customer rule: {CUSTOMER_DEFINITION}
- Scope: {ACCOUNT_SCOPE}
- Write target: {WRITE_TARGET} (account or opportunity)
- Fields: {PAIN_POINTS_FIELD} (long text), {HEALTH_FIELD} (picklist), {INTEGRATIONS_NEEDED_FIELD} (long text)
- Health scale: {HEALTH_SCALE} (default below)
- Transcripts: {TRANSCRIPTS_FOLDER}
- Name mappings: {NAME_MAPPINGS}
- Exclusions: {EXCLUSIONS}
- Required fields (validation): {REQUIRED_FIELDS}
- Report to: {REPORT_RECIPIENTS} and/or {TEAM_CHANNEL}
- Dry-run mode: ON (no CRM writes until the user turns it off)

## Tools
Use the exact names from my skill catalog. Use whatever is connected; report what isn't. Use ONE CRM (Salesforce or HubSpot). On HubSpot there is no cases operator: use notes, tasks and engagements as the support signal.

| Purpose | Tool (exact catalog name) | Required | Access |
|---|---|---|---|
| Accounts/companies, opportunities/deals, cases (Salesforce) or engagements (HubSpot); write the 3 fields | Salesforce: `SalesforceAccountOperator`, `SalesforceOpportunityOperator`, `SalesforceCaseOperator`, `SalesforceActivityOperator`. HubSpot: `HubspotCompanyOperator`, `HubspotDealOperator`, `HubspotEngagementOperator` | Yes (one CRM) | Read; write ONLY the 3 fields, ONLY after approval |
| Search email by company name and domain; send report | `GoogleGmailOperator` or Outlook email operator | Yes | Read; send ONLY to report recipients |
| Read call transcripts | `GoogleDriveCoreOperator` or `Microsoft_OneDrive` folder, or `meeting_archive` (+ `call_archive` for phone calls) | Yes | Read-only |
| Run weekly | Scheduled task (`platform`) | Yes | Platform |
| Tickets and integration requests | `Linear_Operator` | Optional | Read-only |
| Post the report | Slack or Teams (clone messaging integration) | Optional | Post ONLY to {TEAM_CHANNEL} |
| Usage signals for silent risk | `GoogleSheets-Operator` or `Microsoft_Excel` usage export | Optional | Read-only |

## Health scale (default)
- Bright Green: expanding or about to expand; champion engaged; positive feedback; no serious open issues.
- Green: healthy and stable; normal engagement; issues are routine and being handled.
- Yellow: some concern: repeated issues, slower responses, key contact change, mild frustration.
- Orange: real risk: escalation, serious open issue, stalled rollout, budget/priority questions, or silent risk.
- Red: likely churn or downgrade without action: explicit dissatisfaction, evaluating competitors, renewal at risk.
- Black: churned, or churn / non-renewal notice given.

## Guardrails
- Never write to the CRM without explicit approval of this week's change table. If Dry-run mode is ON, never write at all.
- Write ONLY {PAIN_POINTS_FIELD}, {HEALTH_FIELD} and {INTEGRATIONS_NEEDED_FIELD}. Never touch any other field, record or object.
- Never guess or invent values for {REQUIRED_FIELDS} or any field to get past a validation rule. Mark the record "Blocked" and report what's missing.
- Never email or message customers. Only send to {REPORT_RECIPIENTS} / {TEAM_CHANNEL}.
- Every source lookup has exactly one status: "results", "no results" or "FAILED". Never count a failed lookup as zero activity.
- A failed source never makes an account look healthier. If key sources failed for an account, keep its current grade and say so.
- A quiet week alone never changes a grade.
- Only use facts you read in a source. Verify every keyword hit by reading it before using it.
- Skip {EXCLUSIONS} and anything not in {ACCOUNT_SCOPE}.
- Retry rule: if a tool call fails, retry ONCE. If it fails again, mark that source "FAILED" for that account (or for the whole run), continue with the rest, and report it.
- Never ask for or handle passwords or tokens.

## Step 1: Build the account list
1. From the CRM, list records in {ACCOUNT_SCOPE} that match {CUSTOMER_DEFINITION}.
2. Remove {EXCLUSIONS} (internal, test, referral/partner records).
3. For each record capture: name, ID, website/email domain(s), known contact emails, owner, current {HEALTH_FIELD}, current {PAIN_POINTS_FIELD}, current {INTEGRATIONS_NEEDED_FIELD}, and the values of {REQUIRED_FIELDS}.
4. Build search terms per account: official name, aliases, product names and parent/child links from {NAME_MAPPINGS}, and domains.

## Step 2: Sweep the previous 7 days (run the four sources in parallel)
For every account, record each source's status: results / no results / FAILED.
- Call transcripts: search {TRANSCRIPTS_FOLDER} (or `meeting_archive`, plus `call_archive` for phone calls) for files dated in the window that mention the account's search terms or have its attendees.
- Email: search by company name AND by domain AND by known contact addresses (contacts often use personal addresses such as gmail.com or outlook.com). Ignore threads only among {YOUR_COMPANY_DOMAINS} unless they clearly discuss the customer.
- CRM support signal: on Salesforce, list Cases on the account (and child accounts) created or updated in the window, ALL statuses (open and closed). On HubSpot, list notes, tasks and engagements on the company (and child companies) in the window. Then run a secondary text search of case subjects/descriptions (Salesforce) or note/task text (HubSpot) for the search terms to catch cases filed under the wrong account. Note misfiled cases in the report.
- Linear: search issues created or updated in the window that mention the account, its customer link, or its search terms. Note integration requests.
- Product usage (if a usage sheet is connected): activity trend for the window.

## Step 3: Verify the evidence
- Open and read each hit. Keep it only if it is really about this customer (watch for company names that are common words, people's names, or other companies with similar names).
- From verified hits, extract: issues and their severity, sentiment and direct quotes, upcoming changes (renewal, budget, leadership, migration, contract), integration requests, case IDs and ticket IDs, engagement (who joined calls, who replied).

## Step 4: Grade health
1. Start from the current grade.
2. Move the grade only when verified evidence supports it. Write a one-line reason citing the evidence.
3. A quiet week (no verified hits, all sources "no results") does NOT change the grade.
4. If one or more sources FAILED for this account, do not upgrade on missing evidence; keep the grade unless other evidence clearly supports a change, and note the failed sources.
5. Silent risk: flag the account if all sources returned "no results" for the last 7 days AND there are other signs of low use (no recent calls on record, no logins/usage if available, no replies to outreach). Silent risk is listed in the report and may justify Orange; it is never treated as healthy.

## Step 5: Draft the three fields
- {PAIN_POINTS_FIELD}: under ~1,500 characters. Most important fact first. Upcoming changes in ALL CAPS (e.g. "RENEWAL 2027-03-31; NEW VP OPERATIONS STARTING NOV"). Include short direct quotes and case/ticket IDs. Overwrite, but carry forward existing unique detail that is still true. List any existing detail you plan to drop.
- {HEALTH_FIELD}: one value from the scale, spelled exactly like the picklist.
- {INTEGRATIONS_NEEDED_FIELD}: never blank. List each requested integration with its ticket ID; flag requests with NO tracker ticket. If none: "None requested". Carry forward still-open requests.
- Check {REQUIRED_FIELDS} on the record. If any are empty, mark the record "Blocked: missing {field}" and don't plan a write.

## Step 6: Approval request
Send to {REPORT_RECIPIENTS} (and/or post to {TEAM_CHANNEL}) a change table:

| Account | Old grade → New grade | Reason | Pain points diff | Integrations diff | Flags |
|---|---|---|---|---|---|

Flags: DOWNGRADE, LOST DETAIL (with the text being dropped), BLOCKED (with missing fields), SOURCE FAILED, SILENT RISK.
Also list unchanged accounts in one line each. Ask: "Reply yes to write all, yes except [accounts], or no."
If Dry-run mode is ON, label the message "DRY RUN: no changes will be written" and stop after the report in Step 8.

## Step 7: Write approved changes
- Only after an explicit yes, and only for approved records.
- Write in batches of 2–4 records. After each batch, confirm the saved values by reading them back.
- Write only the three fields. If a save fails, retry once; if it fails again, record the exact error message verbatim and move on.

## Step 8: Weekly report
Send to {REPORT_RECIPIENTS} and/or post to {TEAM_CHANNEL}. Subject: "Account Health: week of {date}: {N} updated, {M} need attention".
1. Summary: accounts in scope, updated, unchanged, blocked, failed writes.
2. Health distribution: count per grade, and change since last week.
3. Movers: each upgrade and downgrade with the reason.
4. Silent risk: accounts with no activity and why it's a concern.
5. Failures: exact error messages per record; blocked records and missing fields.
6. Tracking gaps: integration requests without tickets, misfiled cases, sources that FAILED (per account or whole run), mappings that may be missing.
7. Source status: each source as worked / no results / FAILED (after retry).
~~~~

## 8. Test plan

Run this before relying on the weekly schedule. Ask the user to approve the test first. Never use real customers for write tests.

1. **Dry run on real data (no writes).** Run the skill with Dry-run mode ON for the full scope (or 5–10 accounts if the book is large). Nothing is written and no one but the user receives the report.
2. **User reviews grades** with someone who knows the accounts: are grades and reasons fair? Any false positives? Any missed escalations?
3. **Write test on a test record.** The user creates a **test account** (or opportunity) in the CRM, clearly named, e.g. "TEST: Health Autopilot", marked as a customer per `{CUSTOMER_DEFINITION}`, with `{REQUIRED_FIELDS}` filled. Optionally the user sends one email to the clone from a test address mentioning the test account, so there is something to find. With the user's approval, turn dry run off **for this test record only** and write it.
4. **Verify the checklist together:**

| Check | Pass? |
|---|---|
| Every source shows results / no results / FAILED (no source silently missing) | ☐ |
| A deliberately broken or unavailable source shows as FAILED, not "no results" | ☐ |
| Keyword hits were verified; no unrelated emails or transcripts cited | ☐ |
| `{EXCLUSIONS}` were skipped; `{NAME_MAPPINGS}` matched aliases correctly | ☐ |
| Quiet accounts kept their grade; silent-risk accounts were flagged | ☐ |
| Change table shows old → new grade, reason, diffs, and DOWNGRADE / LOST DETAIL / BLOCKED flags | ☐ |
| Dry run wrote **nothing** to the CRM | ☐ |
| Test record: only the three fields changed; values read back correctly; picklist value valid | ☐ |
| `{INTEGRATIONS_NEEDED_FIELD}` is not blank ("None requested" if none) | ☐ |
| Report arrived at `{REPORT_RECIPIENTS}` / `{TEAM_CHANNEL}` only | ☐ |
| **No email was sent to any customer or test contact** | ☐ |

5. Fix anything that failed, re-run, then the user **deletes the test record**. Dry-run mode stays ON until the user says "turn off dry run".

## 9. Final status checklist

When you finish, send the user a status summary in this format:

**✅ Done by me**
- [ ] Discovery table shared (including the three CRM fields)
- [ ] Placeholder values confirmed
- [ ] Required skills/operators attached: …
- [ ] Optional add-ons attached: …
- [ ] Three CRM fields created (or step-by-step instructions handed over)
- [ ] Account Health Autopilot skill created with Dry-run mode ON (or full text handed over for copy-paste)
- [ ] Scheduled task "Weekly Account Health Autopilot" created for `{RUN_TIME}`
- [ ] Dry run and test-record write completed; results: …
- [ ] (If the user wants it) Mentioned the prebuilt skill Weekly-Account-Health-Update as a quick-start alternative

**⏳ Waiting on you**
- [ ] Sign in to: …
- [ ] Share `{TRANSCRIPTS_FOLDER}` with `{CLONE_INBOX}`
- [ ] Grant the CRM integration user edit access to the three fields
- [ ] Create the three fields (if I couldn't)
- [ ] Confirm `{REQUIRED_FIELDS}` / validation rules
- [ ] Save the Account Health Autopilot skill (if I handed it over)
- [ ] Review the dry run, then tell me "turn off dry run"
- [ ] Delete the test record

**💡 Optional next steps**
- [ ] Connect Linear, Slack/Teams or a product usage sheet for better signals
- [ ] Refine `{HEALTH_SCALE}` definitions with your CS team
- [ ] Review `{NAME_MAPPINGS}` and `{EXCLUSIONS}` after the first month
- [ ] Add a "renewals in the next 90 days" section to the report