@uipath/skills 1.195.0

package/skills/uipath-agents/references/lowcode/capabilities/context/index.md

@@ -0,0 +1,264 @@
+# Index Context (Context Grounding RAG)
+
+Walkthrough for adding a context resource backed by an ECS Context Grounding index. Used for RAG (retrieval-augmented generation) — the agent issues queries against the index and gets back relevant chunks.
+
+For other context variants, see [context.md](context.md).
+
+## When to Use
+
+- Agent needs to retrieve from a knowledge base of indexed documents
+- The index already exists in Context Grounding and is backed by an Orchestrator storage bucket
+
+`uip solution resource refresh` emits an `index` binding into `bindings_v2.json`, resolves the backing storage bucket via ECS + Orchestrator, and writes all three artifacts automatically: `resources/solution_folder/index/<IndexName>.json`, `resources/solution_folder/bucket/orchestratorBucket/<BucketName>.json`, and two `debug_overwrites.json` entries (`kind: "index"`, `kind: "bucket"`). No manual solution-level authoring is required.
+
+**Only `contextType: "index"` with a StorageBucket data source is supported.** `attachments` and `datafabricentityset` contexts, and indexes backed by GoogleDrive / OneDrive / Dropbox / Confluence, emit a warning from refresh and must be hand-authored.
+
+## Discovery
+
+Two `uip` calls — identity from `resource list`, full configuration from `resource get`. Symmetric with [../process/process.md § Discovery](../process/process.md#discovery).
+
+### Step 1 — Verify login and scaffold (if not already done)
+
+Run `uip login status --output json`. If a solution and agent do not yet exist, scaffold per [../../project-lifecycle.md § End-to-End Example](../../project-lifecycle.md#end-to-end-example--new-standalone-agent).
+
+### Step 2 — Find the index (identity)
+
+```bash
+uip solution resource list --kind Index --source remote --search "<INDEX_NAME>" --output json
+```
+
+Response wrapper: `{Result, Code: "ResourceList", Data: [...]}` — parse `.Data[]`.
+
+| Field | Use as |
+|-------|--------|
+| `Key` | index GUID — pass to `resource get` in Step 3. Not stored in the agent resource. |
+| `Name` | exact `indexName` to set in the context resource → also propagates as binding `name` |
+| `Folder` | literal folder path → top-level `folderPath` (e.g., `"Shared/Knowledge"`) and binding `folderPath`. Refresh uses `(name, folderPath)` jointly to look up the index in ECS. |
+| `FolderKey` | folder GUID. Refresh resolves it from `Folder`; informational here. |
+
+When the same `Name` repeats across folders, pick by `Key`.
+
+### Step 3 — Get the index configuration
+
+```bash
+uip solution resource get <KEY> --output json
+```
+
+Response wrapper: `{Result, Code: "ResourceConfiguration", Data: {...}}`. `Data.spec` is the source-of-truth that `uip solution resource refresh` round-trips into `resources/solution_folder/index/<IndexName>.json` — confirm it before authoring.
+
+| `Data.spec` field | Confirms / Use as |
+|-------|------------------|
+| `dataSourceType` | MUST equal `"StorageBucket"`. Anything else (GoogleDrive / OneDrive / Dropbox / Confluence / Attachments) — refresh warns + skips. Hand-author solution-level files or escalate. |
+| `storageBucketReference.name` | Bucket display name. Refresh writes this as the bucket manifest's `name`. Optionally cross-check with `uip solution resource list --kind Bucket --source remote --search "<NAME>" --output json` to confirm the bucket is reachable. |
+| `storageBucketReference.key` | Bucket GUID — refresh writes this verbatim as `key` in the bucket manifest and as `dependencies[].key` / `spec.storageBucketReference.key` in the index manifest. |
+| `storageBucketReference.folderKey` | Folder GUID containing the bucket. Matches the index's `FolderKey` from Step 2 (the bucket lives in the same folder as the index). |
+| `fileNameGlob` | File-extension filter on the index itself. Sanity-check — does not need to match the agent resource's `settings.fileExtension.value`. |
+| `includeSubfolders`, `ingestionType`, `encrypted` | Reference fields — refresh round-trips them into the solution-level index manifest. |
+
+Wrapper-level `apiVersion` is `"ecs.uipath.com/v2"` — matches what refresh writes.
+
+## Agent-Level Resource Shape
+
+**Path:** `<AgentName>/resources/<ContextName>/resource.json`
+
+```jsonc
+{
+  "$resourceType": "context",
+  "id": "<uuid>",                       // stable; generate once
+  "referenceKey": null,                 // leave null; refresh resolves the ECS index GUID by indexName
+  "name": "<ContextName>",              // display name; matches the folder under resources/
+  "description": "",
+  "contextType": "index",
+  "folderPath": "Shared/Knowledge",     // Literal Folder from `uip solution resource list`. Propagates verbatim into bindings_v2.json.
+  "indexName": "<IndexName>",           // MUST match the ECS index Name exactly (case-sensitive)
+  "settings": {
+    "retrievalMode": "semantic",        // "semantic" | "structured" | "deeprag" | "batchtransform"
+    "query": { "variant": "dynamic", "description": "Query for retrieval" },
+    "folderPathPrefix": { "variant": "static" },
+    "fileExtension": { "value": "All" },  // object, not string
+    "threshold": 0,
+    "resultCount": 3
+  }
+}
+```
+
+**`retrievalMode` values (all lowercase) and per-mode `fileExtension.value` + extra fields:**
+
+| `retrievalMode` | Legal `fileExtension.value` | Extra required fields |
+|---|---|---|
+| `"semantic"` | `"All"`, `"pdf"`, `"csv"`, `"json"`, `"docx"`, `"xlsx"`, `"txt"` | none |
+| `"structured"` | `"csv"` | none |
+| `"deeprag"` | `"pdf"`, `"txt"` | `"citationMode": { "value": "Inline" }` (or `"Skip"`) |
+| `"batchtransform"` | `"csv"` | `"webSearchGrounding": { "value": "Enabled" }` (or `"Disabled"`), `"outputColumns": [{ "name": "...", "description": "..." }, ...]` |
+
+**`query.variant`:** `"dynamic"` (LLM supplies at runtime), `"argument"` (bound to an input field), or `"static"` (pre-set value).
+
+**`folderPathPrefix.variant`:** `"static"` (no prefix) or `"argument"` (scope by a folder path provided at runtime).
+
+**Casing matters.** All `contextType` and `retrievalMode` values are lowercase. See [../../critical-rules.md](../../critical-rules.md) Anti-pattern 12.
+
+## Solution-Level Files
+
+For `contextType: "index"` with a StorageBucket-backed ECS index, `uip agent migrate` emits:
+
+```json
+{
+  "resource": "index",
+  "key": "<IndexName>",
+  "value": {
+    "name":       { "defaultValue": "<IndexName>", "isExpression": false, "displayName": "Index Name" },
+    "folderPath": { "defaultValue": "<Folder>",    "isExpression": false }
+  },
+  "metadata": { "bindingsVersion": "2.2", "solutionsSupport": "true" }
+}
+```
+
+into `bindings_v2.json` at the agent project root. `folderPath` is propagated verbatim from the agent-level `resource.json`'s top-level `folderPath` field. `uip solution resource refresh` then:
+
+1. Calls ECS `GET ecs_/v2/indexes/AllAcrossFolders?$filter=Name eq '<IndexName>'&$expand=dataSource` — resolves the index GUID, folder key, and data source type. With the binding's `folderPath` set, refresh narrows multi-folder name collisions to the exact deployment.
+2. If `dataSource.@odata.type` is not `#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSource`, warns + skips (other data sources — GoogleDrive, OneDrive, Dropbox, Confluence, Attachments — are not yet wired).
+3. Calls Orchestrator `GET orchestrator_/odata/Buckets?$filter=Name eq '<BucketName>'` with the index's `folderKey` as `X-UIPATH-FolderKey` — gets the bucket `Identifier` GUID.
+4. Registers the bucket as a solution resource via the resource-builder SDK — writes `resources/solution_folder/bucket/orchestratorBucket/<BucketName>.json`.
+5. Hand-writes `resources/solution_folder/index/<IndexName>.json` with `kind: "index"`, `apiVersion: "ecs.uipath.com/v2"`, `dependencies: [{name: "<BucketName>", kind: "bucket"}]`, `spec.storageBucketReference: { name, key }`, `dataSourceType: "StorageBucket"`.
+6. Appends two entries (`kind: "index"` + `kind: "bucket"`) to `userProfile/<userId>/debug_overwrites.json`.
+
+All failures (index not found, ambiguous name match, non-StorageBucket data source, bucket missing in Orchestrator) warn + continue — the command never aborts.
+
+### Index Definition (refresh fallback)
+
+**Path:** `resources/solution_folder/index/{IndexName}.json`
+
+```jsonc
+{
+  "docVersion": "1.0.0",
+  "resource": {
+    "name": "MyIndex",
+    "kind": "index",
+    "apiVersion": "ecs.uipath.com/v2",
+    "isOverridable": true,
+    "dependencies": [
+      {
+        "name": "my_storage_bucket",
+        "kind": "bucket",
+        "key": "<bucket-resource-uuid>"
+      }
+    ],
+    "spec": {
+      "name": "MyIndex",
+      "description": "",
+      "storageBucketReference": {
+        "name": "my_storage_bucket",
+        "key": "<bucket-resource-uuid>"
+      },
+      "fileNameGlob": "All",
+      "dataSourceType": "StorageBucket",
+      "includeSubfolders": true,
+      "ingestionType": "Advanced"
+    },
+    "key": "<unique-uuid>"
+  }
+}
+```
+
+### Storage Bucket Definition (refresh fallback)
+
+**Path:** `resources/solution_folder/bucket/orchestratorBucket/{BucketName}.json`
+
+```jsonc
+{
+  "docVersion": "1.0.0",
+  "resource": {
+    "name": "my_storage_bucket",
+    "kind": "bucket",
+    "type": "orchestratorBucket",
+    "apiVersion": "orchestrator.uipath.com/v1",
+    "isOverridable": true,
+    "spec": {
+      "type": "Orchestrator",
+      "description": null,
+      "tags": []
+    },
+    "key": "<unique-uuid>"
+  }
+}
+```
+
+## Walkthrough
+
+### Step 4 — Create the agent-level context resource
+
+**Path:** `<AgentName>/resources/<ContextName>/resource.json`
+
+```jsonc
+{
+  "$resourceType": "context",
+  "id": "<uuid>",                       // generate a fresh UUID
+  "referenceKey": null,
+  "name": "<ContextName>",
+  "description": "",
+  "contextType": "index",
+  "folderPath": "<FOLDER>",             // literal Folder from Step 2 (e.g., "Shared/Knowledge")
+  "indexName": "<INDEX_NAME>",          // exact ECS index name from Step 2
+  "settings": {
+    "retrievalMode": "semantic",
+    "query": { "variant": "dynamic" },
+    "folderPathPrefix": { "variant": "static" },
+    "fileExtension": { "value": "All" },
+    "threshold": 0,
+    "resultCount": 3
+  }
+}
+```
+
+See § Agent-Level Resource Shape above for the full field reference, including the three variants (`index`/`attachments`/`datafabricentityset`) and per-`retrievalMode` settings (`citationMode` for `deeprag`, `webSearchGrounding` + `outputColumns` for `batchtransform`).
+
+### Step 5 — Validate and migrate
+
+```bash
+uip agent validate "<AGENT_NAME>" --output json
+uip agent migrate  "<AGENT_NAME>" --output json
+```
+
+Validate is read-only. Migrate writes the binding. Confirm `Validated.resources` includes the context, then inspect the emitted binding:
+
+```bash
+cat "<AGENT_NAME>/bindings_v2.json"
+# Expect: resources[0] with {resource: "index", key: "<INDEX_NAME>", ...}
+```
+
+### Step 6 — Refresh solution resources
+
+```bash
+uip solution resource refresh --output json
+```
+
+Refresh resolves the index via ECS `$expand=dataSource`, locates its backing StorageBucket in Orchestrator, and writes:
+
+- `resources/solution_folder/index/<INDEX_NAME>.json` — manifest with `kind: "index"`, `apiVersion: "ecs.uipath.com/v2"`, `dependencies: [{name, kind: "bucket"}]`, `spec.storageBucketReference.{name,key}`.
+- `resources/solution_folder/bucket/orchestratorBucket/<BucketName>.json` — standard bucket manifest.
+- `userProfile/<userId>/debug_overwrites.json` — two entries (`kind: "index"` and `kind: "bucket"`), both referencing the index's folder.
+
+Check the `Warnings` array in the refresh output. Common warnings:
+- `Index "<NAME>" not found in ECS` — exact-name mismatch. Re-check the index name.
+- `Index uses <type>, which is not yet supported` — data source is GoogleDrive/OneDrive/Dropbox/Confluence/Attachments; hand-author the solution-level files. Step 3's `dataSourceType` check should have caught this earlier.
+- `Storage bucket "<NAME>" not found in Orchestrator folder` — the bucket was deleted or lives in a different folder than the index.
+
+### Step 7 — Bundle and upload
+
+```bash
+uip solution bundle . -d ./dist --output json
+uip solution upload ./dist/<SOLUTION_NAME>.uis --output json
+```
+
+The upload response includes a `Data.DesignerUrl` — open it to verify the context appears wired to the ECS index in Studio Web.
+
+## Gotchas
+
+`contextType` and `retrievalMode` values MUST be lowercase — see [../../critical-rules.md](../../critical-rules.md) Anti-pattern 12.
+
+## References
+
+- [context.md](context.md) — capability overview and variant decision
+- [attachments.md](attachments.md) — runtime file attachments
+- [datafabric.md](datafabric.md) — DataFabric entity-set context
+- [../../solution-resources.md](../../solution-resources.md) § Refresh Mechanics

package/skills/uipath-agents/references/lowcode/capabilities/escalation/escalation.md

@@ -0,0 +1,268 @@
+# Action Center Escalation (Human-in-the-Loop)
+
+Walkthrough for adding an escalation resource that hands off agent control to a human via a deployed UiPath Action Center app (a web app of kind `workflow Action`). The agent pauses, creates a task on the app, and resumes when the human picks an outcome.
+
+The only channel type currently supported end-to-end by `uip solution resource refresh` is `actionCenter`. Other channel types (`email`, `slack`, `teams`) are recognised by the runtime but have no automatic solution-level resource generation and are out of scope for this skill.
+
+## When to Use
+
+- Agent needs human approval, review, or input mid-execution
+- A UiPath Action Center app of kind `Workflow Action` is already deployed in Orchestrator
+
+**Key pattern:** the skill writes only the agent-level `resources/{EscalationName}/resource.json`. `uip solution resource refresh` emits an App binding into `bindings_v2.json` and then hand-writes the four solution-level files (`app/workflow Action/`, `appVersion/`, `package/`, `process/webApp/`) plus two `debug_overwrites.json` entries (`kind: "app"`, `kind: "process"`) automatically. No manual solution-level authoring is required for `actionCenter` channels.
+
+## Discovery
+
+### Step 1 — Scaffold solution and agent (if not already done)
+
+Scaffold per [../../project-lifecycle.md § End-to-End Example](../../project-lifecycle.md#end-to-end-example--new-standalone-agent).
+
+### Step 2 — Find the deployed Action Center app
+
+```bash
+uip solution resource list --kind App --source remote --search "<APP_NAME>" --output json
+```
+
+Filter the result for entries whose `Type` is `"Workflow Action"` (Coded / CodedAction types cannot back an escalation today). Each entry carries:
+
+| `resource list` field | Use as |
+|-----------------------|--------|
+| `Key` | `channel.properties.resourceKey` (also becomes the app resource's `key`) |
+| `Name` | `channel.properties.appName` (also propagates as binding `name`) |
+| `Folder` | `channel.properties.folderName` — literal Orchestrator folder (e.g., `"Shared/Approvals"`). `uip agent migrate` translates it to `folderPath` in the App binding inside `bindings_v2.json`. |
+| `FolderKey` | folder GUID — used in `debug_overwrites.json` |
+
+`Key` gives you everything you need to identify the backing app, but `resource list` does not return `systemName` or `deployVersion` — both are required to fetch the action schema in Step 3. Query the Apps API once, filtered client-side by `id == <KEY>`, to extract them:
+
+```bash
+# SECURITY: Never read the auth file directly. Keep the token inside the shell.
+# Auth lives at $HOME/.uipath/.auth normally; fall back to /.uipath/.auth (root) for some sandboxes.
+bash -c 'A="$HOME/.uipath/.auth"; [ -f "$A" ] || A="/.uipath/.auth"; set -a; source "$A"; set +a; curl -s \
+  "${UIPATH_URL}/${UIPATH_ORGANIZATION_ID}/apps_/default/api/v1/default/action-apps?state=deployed&pageNumber=0&limit=100" \
+  -H "Authorization: Bearer $UIPATH_ACCESS_TOKEN" \
+  -H "X-Uipath-Tenantid: $UIPATH_TENANT_ID" \
+  -H "Accept: application/json"'
+```
+
+From the matching entry in `.deployed[]`, extract:
+
+| Field | Use as |
+|-------|--------|
+| `systemName` | `appSystemName` query parameter for action-schema (Step 3) |
+| `deployVersion` | `channel.properties.appVersion` (integer) AND `version` query parameter for action-schema |
+
+### Step 3 — Fetch the app's action schema
+
+Use `systemName` and `deployVersion` from Step 2.
+
+```bash
+bash -c 'A="$HOME/.uipath/.auth"; [ -f "$A" ] || A="/.uipath/.auth"; set -a; source "$A"; set +a; curl -s \
+  "${UIPATH_URL}/${UIPATH_ORGANIZATION_ID}/apps_/default/api/v1/default/action-schema?appSystemName=<SYSTEM_NAME>&version=<DEPLOY_VERSION>" \
+  -H "Authorization: Bearer $UIPATH_ACCESS_TOKEN" \
+  -H "X-Uipath-Tenantid: $UIPATH_TENANT_ID" \
+  -H "Accept: application/json"'
+```
+
+Response shape:
+
+```jsonc
+{
+  "inputs":   [{ "name": "Content", "type": "System.String", ... }],
+  "outputs":  [],
+  "inOuts":   [{ "name": "Comment", "type": "System.String", "description": "..." }],
+  "outcomes": [{ "name": "approve", "description": "..." }, { "name": "reject", ... }]
+}
+```
+
+### Step 4 — Build the channel schemas
+
+From the action-schema response, construct the channel fields:
+
+- `channel.inputSchema` — object whose `properties` combine every `inputs[]` entry + every `inOuts[]` entry. Map each dotnet `type` to a JSON Schema type using the same rules as external RPA tools (`System.String` → `"string"`, `System.Int32`/`Int64`/`Decimal`/`Double` → `"number"`, `System.Boolean` → `"boolean"`, other → `"string"`). Preserve `description` when present.
+- `channel.outputSchema` — object whose `properties` combine every `inOuts[]` entry + every `outputs[]` entry. Same mapping rules.
+- `channel.inputSchemaDotnetTypeMapping` / `outputSchemaDotnetTypeMapping` — flat object keyed by arg `name`, value = the raw dotnet type string.
+- `channel.outcomeMapping` — one key per `outcomes[].name`, value defaults to `"continue"`. Ask the user which outcomes should `"end"` the agent run.
+
+### Step 5 — Ask for recipients and task title
+
+**Recipients are mandatory.** An escalation with an empty `recipients: []` uploads cleanly but Studio Web shows the escalation with no assignee and the runtime task will not route. Always collect at least one recipient.
+
+**Default to email recipients (`type: 3`).** This is the simplest form — you don't need to look up user GUIDs or display names:
+
+```jsonc
+"recipients": [
+  { "type": 3, "value": "user@example.com" }
+]
+```
+
+Ask the user who should receive the task. If they say "me" or don't specify, fall back to the current user's email from the JWT `email` claim:
+
+```bash
+bash -c 'A="$HOME/.uipath/.auth"; [ -f "$A" ] || A="/.uipath/.auth"; set -a; source "$A"; set +a; echo "$UIPATH_ACCESS_TOKEN" | python3 -c "
+import sys, base64, json
+tok = sys.stdin.read().strip()
+payload = tok.split(\".\")[1]
+payload += \"=\" * (-len(payload) % 4)
+print(json.loads(base64.urlsafe_b64decode(payload)).get(\"email\"))
+"'
+```
+
+Use other `type` values (1=UserId, 2=GroupId, 4=AssetUserEmail, 5=StaticGroupName, 6=AssetGroupName) only when the user explicitly asks for a GUID-based recipient or an asset-backed one — they require additional inputs (user/group GUID from the Identity API, or an asset name).
+
+> **Do not set `displayName` for `type: 3`.** The reference solution omits it; leaving it out results in cleaner rendering in Studio Web.
+
+**`channel.properties.folderName` must be the literal `Folder` from `uip solution resource list --kind App`** (e.g., `"Shared/Approvals"`). `uip agent migrate` translates it to `folderPath` in the App binding inside `bindings_v2.json`. Do NOT set it to `"solution_folder"` — escalation apps are always external.
+
+Default `taskTitle` / `taskTitleV2` to a short human-readable label — e.g., `"Approval request"`. `taskTitle` is a string; `taskTitleV2` is a `contentTokens`-style object (see [../../agent-definition.md](../../agent-definition.md) § Messages).
+
+## Agent-Level Resource Shape
+
+**Path:** `<AGENT_NAME>/resources/<EscalationName>/resource.json`
+
+Escalations hand off agent control to a human via a channel. Generate fresh UUIDs for the top-level `id` AND the channel `id` — do not reuse.
+
+```jsonc
+{
+  "$resourceType": "escalation",
+  "id": "<uuid-v4>",                                // stable; generate once, never change
+  "name": "MyEscalation",                           // folder name & resource name must match
+  "description": "Escalate to a human assistant for approval",
+  "escalationType": 0,                              // 0 = Escalation, 1 = VsEscalation
+  "isAgentMemoryEnabled": false,
+  "ixpToolId": null,                                // only used when escalationType = 1
+  "storageBucketName": null,                        // only used when escalationType = 1
+  "properties": {},
+  "governanceProperties": { "isEscalatedAtRuntime": false },
+  "isEnabled": true,
+  "channels": [
+    {
+      "id": "<uuid-v4>",                            // channel id — generate a new one per channel
+      "name": "Channel",
+      "description": "Channel description",
+      "type": "actionCenter",                       // lowercase. Other values: "email", "slack", "teams"
+      "inputSchema": {                              // derived from action-schema.inputs + action-schema.inOuts
+        "type": "object",
+        "properties": {
+          "<argName>": { "type": "<jsonSchemaType>", "description": "<desc>" }
+        }
+      },
+      "inputSchemaDotnetTypeMapping": {             // { argName: "System.String" | "System.Int32" | ... }
+        "<argName>": "System.String"
+      },
+      "outputSchema": {                             // derived from action-schema.inOuts + action-schema.outputs
+        "type": "object",
+        "properties": {
+          "<argName>": { "type": "<jsonSchemaType>", "description": "<desc>" }
+        }
+      },
+      "outputSchemaDotnetTypeMapping": {
+        "<argName>": "System.String"
+      },
+      "outcomeMapping": {                           // one key per action-schema.outcomes[].name
+        "<outcomeName>": "continue"                 // "continue" (agent resumes) | "end" (agent stops)
+      },
+      "properties": {
+        "resourceKey": "<appId-guid>",              // from `action-apps?state=deployed` → `id`
+        "appName": "<deploymentTitle>",             // from the same response → `deploymentTitle`
+        "folderName": "Shared/Approvals",           // literal Folder from `uip solution resource list --kind App`. uip agent migrate translates this to folderPath in the App binding inside bindings_v2.json.
+        "appVersion": 1,                            // from the same response → `deployVersion` (integer)
+        "isActionableMessageEnabled": false,
+        "actionableMessageMetaData": null
+      },
+      "recipients": [                               // REQUIRED — at least one. Empty array uploads but Studio Web shows the escalation with no assignee.
+        {
+          "type": 3,                                // RecipientType: 1=UserId, 2=GroupId, 3=UserEmail (preferred — simplest),
+                                                    //   4=AssetUserEmail, 5=StaticGroupName, 6=AssetGroupName
+          "value": "user@example.com"               // for type 3, the email string. For type 1/2, a user/group GUID.
+                                                    // `displayName` is NOT required for type 3 — omit it.
+        }
+      ],
+      "taskTitle": "Approval request",              // deprecated but still written for back-compat
+      "taskTitleV2": {
+        "type": "textBuilder",                      // or "dynamic" (single string) — see contentTokens rules
+        "tokens": [
+          { "type": "simpleText", "rawString": "Approval request" }
+        ]
+      },
+      "labels": []                                  // optional string tags
+    }
+  ]
+}
+```
+
+**`outcomeMapping` rules:**
+- One entry per outcome returned by the app's `action-schema` (e.g., `approve`, `reject`).
+- Each value is `"continue"` (agent processes the outcome and continues) or `"end"` (agent stops when the outcome fires).
+- Default every outcome to `"continue"` unless the user has specified otherwise.
+
+**`inputSchema` / `outputSchema` derivation from the action schema response:**
+- `channel.inputSchema.properties` = union of `action-schema.inputs[].name` and `action-schema.inOuts[].name` — these are what the human sees in the task form.
+- `channel.outputSchema.properties` = union of `action-schema.inOuts[].name` and `action-schema.outputs[].name` — these are what the agent receives back.
+- For each property, set `type` by mapping the dotnet type string in the same way as external RPA process tools (`System.String` → `"string"`, `System.Int32`/`Int64`/`Decimal`/`Double` → `"number"`, `System.Boolean` → `"boolean"`, everything else → `"string"`).
+- Copy each arg's `description` verbatim when present.
+- `inputSchemaDotnetTypeMapping` / `outputSchemaDotnetTypeMapping` preserve the raw dotnet type names keyed by arg name — Studio Web uses these when serialising task payloads.
+
+## Solution-Level Files
+
+**Solution-level files for Action Center escalations are auto-generated.** Unlike external process tools, you do NOT hand-write any solution-level files for an escalation. `uip solution resource refresh` scans agent projects for escalation resources, resolves each `properties.resourceKey` against the Apps API + `publish/versions` + Orchestrator `/odata/Releases` + `GetPackageEntryPointsV2`, and writes all four required files itself:
+
+- `resources/solution_folder/app/workflow Action/<deploymentTitle>.json`
+- `resources/solution_folder/appVersion/<title>.json`
+- `resources/solution_folder/package/<title>.json`
+- `resources/solution_folder/process/webApp/<deploymentTitle>.json`
+
+The fourth file (`process/webApp/...`) backs the app resource's `dependencies[1]: {kind: "Process"}` — without it, Studio Web reports "Resource provisioning failed (#100)" on solution import.
+
+## Walkthrough
+
+### Step 6 — Write the agent-level resource.json
+
+**File:** `<AGENT_NAME>/resources/<EscalationName>/resource.json`
+
+Use the full shape from § Agent-Level Resource Shape above. Generate fresh UUIDs for the top-level `id` AND the channel `id` — do not reuse.
+
+### Step 7 — Validate, migrate, and refresh solution resources
+
+```bash
+# Validate — read-only check of agent and resource.json.
+uip agent validate "<AGENT_NAME>" --output json
+
+# Migrate — applies pending schema migrations and writes bindings_v2.json.
+uip agent migrate "<AGENT_NAME>" --output json
+
+# Refresh — imports the App binding from bindings_v2.json into the solution.
+uip solution resource refresh --output json
+```
+
+After refresh, confirm the four solution-level app files exist under `resources/solution_folder/`:
+
+- `app/workflow Action/<AppName>.json`
+- `appVersion/<PkgName>.json`
+- `package/<PkgName>.json`
+- `process/webApp/<AppName>.json`
+
+If any are missing, hand-author them using the templates above and the Apps API + `publish/versions` + Orchestrator `/odata/Releases` data. The `process/webApp/<AppName>.json` file is the one most commonly missing and its absence causes "Resource provisioning failed (#100)" on solution import.
+
+### Step 8 — Bundle and upload
+
+```bash
+uip solution bundle . -d ./dist --output json
+uip solution upload ./dist/<SOLUTION_NAME>.uis --output json
+```
+
+## Gotchas
+
+See [../../critical-rules.md](../../critical-rules.md) Critical Rules. Escalation-specific gotchas:
+
+- `properties.folderName` MUST be the literal `Folder` from `uip solution resource list --kind App` (e.g., `"Shared/Approvals"`). `uip agent migrate` translates it to `folderPath` in the App binding inside `bindings_v2.json`. Do NOT use `"solution_folder"` — escalation apps are always external. See [../../critical-rules.md](../../critical-rules.md) Rule 11 and Anti-pattern 18.
+- `recipients` array MUST have at least one entry. Empty uploads but routes nowhere.
+- For `type: 3` (email) recipients, do NOT set `displayName`.
+- Generate fresh UUIDs for the top-level `id` AND each channel `id`.
+- `channel.type` is lowercase `"actionCenter"`.
+- Other channel types (`email`, `slack`, `teams`) are runtime-recognized but require manual solution authoring — out of scope today.
+
+## References
+
+- [../../agent-definition.md](../../agent-definition.md) § Messages, § contentTokens (for `taskTitleV2`)
+- [../../solution-resources.md](../../solution-resources.md) § Refresh Mechanics
+- [../../project-lifecycle.md](../../project-lifecycle.md) § Resource Discovery