Platform Dsar Policy Manage

platform-dsar-policy-manage: DsarPolicy Right to Portability, end to end

Operate a DsarPolicy — the metadata driving a Right-to-Portability (RTP) export — across its lifecycle: configure the tree, run an export, audit runs. A DsarPolicy is a read/export map: it names which of a subject's records an export collects. It never deletes anything. The value here is judgment, not XML plumbing.

FIRST LINE OF EVERY RESPONSE — do not narrate the skill. Your first output token is work or the answer, never a play-by-play. Do not open with "This is a coverage-gap audit / Workflow D…", "Let me read the skill's guide/mechanics…", "Per rule #1…", or "Let me discover the SOR…". Don't name the workflow, announce which reference files you're about to read, or describe your method before doing it — just start doing it (call the tool) and, when done, present the result. This is load-bearing call #8, stated up front because it governs your very first token. A plain-language sentence about the user's data/org is fine; a sentence about the skill, its workflows, rules, tools, or files is not.

Load-bearing calls (get these right or the task fails)

These override any leading phrasing in the request. Read them first, every time. Call #1 is the literal first action of every task — before you pick a workflow, before any sf command.

1. Route through the SOR tool FIRST — before any sf/endpoint call, no exceptions. The very first action of every task here — including a trivial read-only "does a policy exist / list the policies" lookup — is to scan this run's available tools for a capability-routing tool exposing discover / describe / dispatch verbs (project-codey / Headless 360 today; any host prefix such as mcp__<host>__discover; match the verb shape, not a fixed name). If one is present, that is the entry move: discover → describe → dispatch the DsarPolicyManager SOR (owner Privacy Center; isActive gates execute/edit/delete) and reject look-alikes (data mask, generic consent, subject erasure). Do not reach for sf first — grabbing sf on reflex because the task "looks like a quick lookup" is the top recurring miss, and it is wrong even when it would work. sf is the fallback only when no routing tool is in reach (checking sf org list to see which orgs are authenticated locally is fine — that is a client-side auth check, not a SOR call). Every sf/salesforce-api-context command shown in the workflows below is the no-routing-tool spelling; when the routing tool is present, dispatch the equivalent operation through it instead. Detail: references/headless-sor.md.
2. Export, never erasure. A run produces an export file; it does not erase/redact/delete the subject. If the request frames it as deletion ("remove them", "erase", "clear out"), correct that first and never report the subject as erased. Erasure is a separate mechanism — if that's the goal, say so and stop. You may still export if authorization is clear, after correcting the premise.
3. Do not guess personal data. Which objects/relationships hold the subject's data is the admin's classification call. If the request delegates it ("figure out what counts", "wire the whole thing up"), do not author a guessed tree — enumerate the decisions the admin must make (roots; per-relationship follow/stop; fields), mark any proposal pending admin disposition. An over-broad guess exports other people's records.
4. Caps are hard — name the cap and stop; don't graph-walk. Tree caps: 10 children/path, depth 10, 200 nodes. An unbounded request ("everything", "the whole graph") cannot fit. Do not enumerate the object graph to "try" (never finishes, burns the turn). Name the specific cap exceeded and offer a bounded alternative (split policies, prune branches). Never silently truncate.
5. Poll a couple of times, then ask — don't block on terminal. The run handle serves status and file. An early getfile returns NOT_FOUND / "This file isn't ready yet" — the contract working, not a failure. Poll ≈2–3×; if still not terminal, stop and ask the user whether to keep polling — don't loop. A run can sit non-terminal indefinitely on downstream async processing — platform / Tool Factory territory, not this skill's to diagnose or reach into; report status in plain terms (running / completed / errored) and let the user decide. Never download before terminal. A failed run can return HTTP 201 — read the envelope / RequestStatus in the body, not the HTTP code. getfile segment is dsr, not dsar.
6. History is a read. Run history = a SOQL query over DsarPolicyLog. Not installListView, not a UI list; it starts no run.
7. Never auto-activate or republish. Activation is a deliberate, human-confirmed step. Editing an ACTIVE policy needs it deactivated first — deactivate → edit → stop, report, get explicit user confirmation before reactivating. New policies stay INACTIVE until the user activates. Auto-republishing breaks the reviewable audit trail disputes depend on.
8. Work silently — never narrate the skill's internals (applies to every workflow; see the masthead above). The user asked a domain question; answer it, don't describe how the skill answers it. Run the tools and present the result — no intermediate narration of: that you are about to read / are reading the skill's guide, mechanics, or reference files ("let me read the skill's guide and mechanics"); which workflow this is ("this is a coverage-gap audit / Workflow D", "Workflow C-style read") — the user does not think in workflow letters, so never name one; which SOR/routing tool you're using or that you're "loading schemas / discovering / dispatching"; the load-bearing rule numbers ("per rule #1"); the reject-look-alikes step; the operation graph or GET-vs-dispatch plumbing (getAccessInfo, dispatch_readonly, etc.). These steer how you work — they are not status updates. (The harness still shows its own plain tool-call lines; that is fine — just don't add your own play-by-play.) What the user DOES see: the final answer, and — where a call requires it — a plain-language question (AskUserQuestion) or a short scope/consent line about their org ("I only listed policies; I changed nothing", "this exports, it doesn't delete"). Rule of thumb: a sentence about their data/org can be user-facing; a sentence about the skill, its workflows, steps, tools, rules, or files stays internal. Workflow D's method preamble is the one allowed "here's how I'll do it" line, and even it must be plain-language about the audit approach ("I'll look one level out from your policy's objects and flag fields that might hold personal data") — it names no workflow letter, rule, tool, or file. That preamble is not a licence to say "this is Workflow D" or "let me read the mechanics".

The DsarPolicy object model

Each entity is reached a different way — guessing the surface is the top time-sink.

Resolve the exact Connect route/version at run time via salesforce-api-context (or sf). Don't sf sobject describe DsarPolicy* — the tree is metadata; only DsarPolicyLog answers standard SOQL. On an MCP surface, each row is one DsarPolicyManager operation.

Pick the workflow (by the verb)

Mixed request → do the one asked; don't add an export to a configure, or a run to a history.

Every workflow below assumes call #1 is already done — you have routed through the discover/ describe/dispatch SOR tool (or confirmed none is in reach). The sf/salesforce-api-context commands in each workflow are the no-routing-tool spelling; with the routing tool present, dispatch the equivalent operation through it.

Workflow A — Configure

Recipe (metadata shape, relationship/field resolution, lifecycle transitions): references/configure.md.

1. Classify first — short-circuit before any describe. Three shapes; two never reach authoring:
   • Unbounded ("everything", "whole graph") — can't fit caps. Don't describe/walk. Write the cap-refusal report (call #3), stop.
   • Under-specified — delegates classification, no root/field named. Don't author a guess. Write the elicitation report (the admin's decisions; support multiple roots; proposals pending disposition), stop.
   • Bounded & specified — named roots/relationships/fields fitting the caps → continue.
2. Confirm type + describe named objects only (don't assume names, don't expand beyond what's named):

   sf org list metadata --metadata-type DsarPolicy --target-org <alias> --json
   sf sobject describe --sobject <NamedObject> --target-org <alias> --json

   If DsarPolicy can't be listed/described, surface it and stop (accepted terminal outcome).
3. Validate the tree (don't eyeball caps/names):

   python3 scripts/validate-policy-tree.py <tree.json>

   Checks children≤10, depth≤10, nodes≤200, and devname [a-zA-Z]+[a-zA-Z0-9_]*.
4. Author metadata INACTIVE under ${outputDir}, faithful to the sanctioned strategy — add no unapproved path, drop none approved.

   Lifecycle gate: INACTIVE to edit/delete, ACTIVE to execute. Change an ACTIVE policy by deactivate → edit → STOP; get explicit user confirmation before reactivating (call #7).

5. Deploy (best effort): sf project deploy start --source-dir <outputDir> --target-org <alias> --json. Deploy may fail where the type isn't fully enabled — surface the raw error + prerequisite; don't fake success. The classification work is valid regardless.
6. Report the outcome reached — cap-refusal / elicitation / authored — per references/report-format.md. Never a truncated tree called "complete".