@parall/parall 1.47.0 → 1.49.0

package/dist/index.bundle.mjs

@@ -51349,6 +51349,8 @@ var ENDPOINTS = {
   MESSAGE_WATCH: (id) => `${API_BASE}/messages/${id}/watch`,
   MESSAGE_WATCHERS: (id) => `${API_BASE}/messages/${id}/watchers`,
   MESSAGE_WATCHING: (id) => `${API_BASE}/messages/${id}/watching`,
+  MESSAGE_REACTIONS: (id) => `${API_BASE}/messages/${id}/reactions`,
+  MESSAGE_REACTION: (id, emoji) => `${API_BASE}/messages/${id}/reactions/${encodeURIComponent(emoji)}`,
   // Upload (org-scoped)
   UPLOAD_PRESIGN: (orgId) => `${API_BASE}/orgs/${orgId}/upload/presign`,
   UPLOAD_COMPLETE: (orgId) => `${API_BASE}/orgs/${orgId}/upload/complete`,
@@ -51586,11 +51588,13 @@ var ENDPOINTS = {
   UNREAD: `${API_BASE}/me/unread`,
   ORG_UNREAD: (orgId) => `${API_BASE}/orgs/${orgId}/unread`,
   CHAT_READ: (orgId, chatId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/read`,
+  CHAT_READ_ALL: (orgId, chatId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/read-all`,
   THREAD_UNREAD: (orgId, chatId, threadRootId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/threads/${threadRootId}/unread`,
   THREAD_READ: (orgId, chatId, threadRootId) => `${API_BASE}/orgs/${orgId}/chats/${chatId}/threads/${threadRootId}/read`,
   // References (org-scoped)
   REFS_RESOLVE: (orgId) => `${API_BASE}/orgs/${orgId}/refs/resolve`,
   REFS_BACKLINKS: (orgId) => `${API_BASE}/orgs/${orgId}/refs/backlinks`,
+  REFS_OUTBOUND: (orgId) => `${API_BASE}/orgs/${orgId}/refs/outbound`,
   REFS_GRAPH: (orgId) => `${API_BASE}/orgs/${orgId}/refs/graph`,
   REFS_CHECK: (orgId) => `${API_BASE}/orgs/${orgId}/refs/check`,
   // Platform config (agent-scoped, not org-scoped)
@@ -51649,10 +51653,23 @@ var ENDPOINTS = {
   ORG_EDGE: (orgId) => `/api/v1/orgs/${orgId}/edge`,
   ORG_EDGE_DEVICES: (orgId) => `/api/v1/orgs/${orgId}/edge/devices`,
   ORG_EDGE_DEVICE: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}`,
+  ORG_EDGE_DEVICE_UNREGISTER: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/unregister`,
   ORG_EDGE_ONBOARDING: (orgId) => `/api/v1/orgs/${orgId}/edge/onboarding`,
   ORG_EDGE_PROFILES: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles`,
+  // Per-profile egress proxy (hosted Cloud Profiles; manager-only, human-only).
+  ORG_EDGE_PROFILE_PROXY: (orgId, edgeId, profileName) => `/api/v1/orgs/${orgId}/edge/${edgeId}/profiles/${encodeURIComponent(profileName)}/proxy`,
+  ORG_EDGE_EXEC: (orgId) => `/api/v1/orgs/${orgId}/edge/exec`,
+  // Cloud Edge live viewer command (V1b) — api-server, gated on cap:edge-viewer.
+  // Same request/reply shape as the v2 browser-profile viewer, on the v3 edge
+  // pipe. Additive: does NOT replace BROWSER_PROFILE_VIEWER_COMMAND.
+  ORG_EDGE_VIEWER_COMMAND: (orgId, edgeId) => `/api/v1/orgs/${orgId}/edge/${edgeId}/viewer/command`,
   CLIP_CONNECTIONS: (orgId, clipId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/connections`,
-  CLIP_CONNECTION: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}`
+  CLIP_CONNECTION: (orgId, connId) => `/api/v1/orgs/${orgId}/clip-connections/${connId}`,
+  // Clip registry (v3, org-scoped, served by api-server — `crg_` entries; the
+  // Pinix Hub catalog proxy above is a different, id-less surface)
+  ORG_CLIP_REGISTRY: (orgId) => `/api/v1/orgs/${orgId}/clip-registry`,
+  ORG_CLIP_INSTALL: (orgId) => `/api/v1/orgs/${orgId}/clips/install`,
+  ORG_CLIPS_INSTALLED: (orgId) => `/api/v1/orgs/${orgId}/clips/installed`
 };
 var WS_EVENTS = {
   // Client -> Server
@@ -51668,6 +51685,7 @@ var WS_EVENTS = {
   MESSAGE_PATCH: "message.patch",
   MESSAGE_EDIT: "message.edit",
   MESSAGE_DELETE: "message.delete",
+  MESSAGE_REACTION_UPDATED: "message.reaction.updated",
   TYPING_UPDATE: "typing.update",
   CHAT_UPDATE: "chat.update",
   CHAT_DELETED: "chat.deleted",
@@ -51709,6 +51727,7 @@ var WS_EVENTS = {
   INBOX_UPDATE: "inbox.update",
   INBOX_BULK_UPDATE: "inbox.bulk_update",
   READ_POSITION_UPDATED: "read_position.updated",
+  THREAD_READ_POSITION_UPDATED: "thread_read_position.updated",
   DISPATCH_NEW: "dispatch.new",
   DISPATCH_RECEIVED: "dispatch.received",
   DISPATCH_RESOLVED: "dispatch.resolved",
@@ -51894,7 +51913,7 @@ var ParallClient = class _ParallClient {
       if (qs)
         url += `?${qs}`;
     }
-    const headers = this.buildHeaders(path9);
+    const headers = this.buildHeaders(path9, opts?.headers);
     const timeoutSignal = AbortSignal.timeout(opts?.timeoutMs ?? 15e3);
     const signal = opts?.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
     let res;
@@ -52300,6 +52319,14 @@ var ParallClient = class _ParallClient {
   async getMessageReplies(id, params) {
     return this.request("GET", ENDPOINTS.MESSAGE_REPLIES(id), void 0, params);
   }
+  // ---- Reactions ----
+  async toggleReaction(messageId, emoji) {
+    return this.request("PUT", ENDPOINTS.MESSAGE_REACTION(messageId, emoji));
+  }
+  async listReactions(messageId) {
+    const res = await this.request("GET", ENDPOINTS.MESSAGE_REACTIONS(messageId));
+    return res.reactions;
+  }
   // ---- File Upload ----
   async getUploadPresignUrl(orgId, req) {
     return this.request("POST", ENDPOINTS.UPLOAD_PRESIGN(orgId), req);
@@ -52675,6 +52702,15 @@ var ParallClient = class _ParallClient {
   async browserViewerCommand(orgId, profileId, req, opts) {
     return this.request("POST", ENDPOINTS.BROWSER_PROFILE_VIEWER_COMMAND(orgId, profileId), req, void 0, false, opts);
   }
+  /**
+   * Drive the Cloud Edge live viewer (V1b, design §6): WebRTC signaling + input +
+   * tab nav for a hosted browser (Cloud Profile). Same request/reply shape as
+   * browserViewerCommand, on the v3 edge pipe; additive — the v2 browser-profile
+   * viewer is unchanged.
+   */
+  async edgeViewerCommand(orgId, edgeId, req, opts) {
+    return this.request("POST", ENDPOINTS.ORG_EDGE_VIEWER_COMMAND(orgId, edgeId), req, void 0, false, opts);
+  }
   async resizeMachine(orgId, machineId, spec) {
     return this.request("PATCH", ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
@@ -52701,14 +52737,23 @@ var ParallClient = class _ParallClient {
   }
   // Wiki mount/token methods removed — wiki-service handles all wiki endpoints.
   // ---- Unread ----
-  async getUnreadCounts(orgId) {
+  async getUnreadCounts(orgId, opts) {
     const endpoint = orgId ? ENDPOINTS.ORG_UNREAD(orgId) : ENDPOINTS.UNREAD;
-    const res = await this.request("GET", endpoint);
+    const res = await this.request("GET", endpoint, void 0, {
+      include_thread_replies: opts?.includeThreadReplies ? "true" : void 0
+    });
     return res.data;
   }
   async markRead(orgId, chatId, messageId) {
     return this.request("POST", ENDPOINTS.CHAT_READ(orgId, chatId), { message_id: messageId });
   }
+  /** Mark everything in a chat read: the channel cursor jumps to the latest
+   *  top-level message and every thread cursor to its latest reply, in one
+   *  idempotent call. The server echoes the same per-cursor WS events the
+   *  single-cursor routes emit and auto-clears covered inbox items. */
+  async markAllRead(orgId, chatId) {
+    return this.request("POST", ENDPOINTS.CHAT_READ_ALL(orgId, chatId));
+  }
   async getThreadUnread(orgId, chatId, threadRootId) {
     return this.request("GET", ENDPOINTS.THREAD_UNREAD(orgId, chatId, threadRootId));
   }
@@ -53383,6 +53428,16 @@ var ParallClient = class _ParallClient {
   async getBacklinks(orgId, params) {
     return this.request("GET", ENDPOINTS.REFS_BACKLINKS(orgId), void 0, params);
   }
+  /**
+   * Outbound prll:// refs authored in a set of sources, as raw ref_links rows
+   * (dedupe/group client-side). Pass `{ thread_root_id }` to list a whole
+   * thread's refs (root + all replies, resolved server-side — the client's
+   * reply window may be partial), or `{ source_type, source_ids }` for
+   * explicit sources (max 500; v1 accepts only message sources).
+   */
+  async listOutboundRefs(orgId, req) {
+    return this.request("POST", ENDPOINTS.REFS_OUTBOUND(orgId), req);
+  }
   /**
    * Bounded multi-hop walk of the prll:// reference graph around `uri`. `uri`
    * must be an entity-level prll:// URI — a refined URI (path/query/fragment) is
@@ -53593,6 +53648,31 @@ var ParallClient = class _ParallClient {
     const resp = await this.request("GET", url);
     return resp.data;
   }
+  // ---- Clip registry (v3, api-server org registry — `crg_` entries) ----
+  /**
+   * List registry clips visible to the org: its own plus public+approved
+   * cross-org entries. This is the surface `installRegistryClip` and clip
+   * connections operate on — NOT the Pinix catalog proxy
+   * ({@link listRegistryClips}), whose entries carry no `crg_` id.
+   */
+  async listOrgRegistryClips(orgId) {
+    const resp = await this.request("GET", `${ENDPOINTS.ORG_CLIP_REGISTRY(orgId)}?limit=100`);
+    return resp ?? [];
+  }
+  /**
+   * Install a registry clip into the org (a reference in `clip_installs`, not a
+   * copy). Idempotent: installing an already-installed clip returns the same
+   * `200 {ok:true}`. Fails closed with `403 CLIP_NOT_APPROVED` when the clip is
+   * not eligible (cross-org requires public + approved).
+   */
+  async installRegistryClip(orgId, clipId) {
+    return this.request("POST", ENDPOINTS.ORG_CLIP_INSTALL(orgId), { clip_id: clipId });
+  }
+  /** List the org's installed registry clips (full entries). */
+  async listInstalledRegistryClips(orgId) {
+    const resp = await this.request("GET", ENDPOINTS.ORG_CLIPS_INSTALLED(orgId));
+    return resp ?? [];
+  }
   // ---- Edge devices ----
   async listEdgeDevices(orgId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_DEVICES(orgId));
@@ -53610,8 +53690,8 @@ var ParallClient = class _ParallClient {
     return this.request("POST", ENDPOINTS.ORG_EDGE(orgId), input);
   }
   /**
-   * Delete a hosted Cloud Profile. Hosted only — a BYOC device is removed by
-   * uninstalling Parall Clip on that machine (`400 EDGE_PLACEMENT_UNSUPPORTED`).
+   * Delete a hosted Cloud Profile. Hosted only — use {@link unregisterEdgeDevice}
+   * for an offline BYOC registration (`400 EDGE_PLACEMENT_UNSUPPORTED` here).
    *
    * Idempotent and ASYNC: returns `202` with `hosted_state: 'deleting'` on the first
    * call and on every repeat. The device stops being usable immediately (no exec, no
@@ -53621,12 +53701,105 @@ var ParallClient = class _ParallClient {
   async deleteEdgeDevice(orgId, edgeId) {
     return this.request("DELETE", ENDPOINTS.ORG_EDGE_DEVICE(orgId, edgeId));
   }
+  /**
+   * Remove the interactive human caller's own offline BYOC registration.
+   *
+   * Synchronous and idempotent: a committed removal and a repeat after removal
+   * both resolve with no response body. A live connection returns `EDGE_ONLINE`;
+   * callers must not clear local device identity until this method resolves.
+   */
+  async unregisterEdgeDevice(orgId, edgeId) {
+    await this.request("DELETE", ENDPOINTS.ORG_EDGE_DEVICE_UNREGISTER(orgId, edgeId));
+  }
   async getEdgeOnboarding(orgId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_ONBOARDING(orgId));
   }
   async listEdgeProfiles(orgId, edgeId) {
     return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILES(orgId, edgeId));
   }
+  /**
+   * Read a hosted Cloud Profile's egress-proxy status (manager-only: hosted
+   * human maintainer or org admin). Sanitized — the password never comes back.
+   * Typed errors: `EDGE_NOT_HOSTED` (BYOC device), `PROXY_CONFIG_CORRUPT` /
+   * validation codes as 422 when a stored config no longer passes current rules.
+   * `can_mutate` and `lease_status` are the authoritative idle gate; device
+   * list status is not a substitute.
+   */
+  async getEdgeProfileProxy(orgId, edgeId, profileName) {
+    return this.request("GET", ENDPOINTS.ORG_EDGE_PROFILE_PROXY(orgId, edgeId, profileName));
+  }
+  /**
+   * Set/replace the profile's egress proxy (full triple every time) — IDLE
+   * ONLY: while the profile's hosted browser is running (a viewer session is
+   * open or a pod is otherwise live) the server answers 409
+   * `EDGE_PROFILE_IN_USE`; close the viewer, wait for idle scale-to-zero, and
+   * retry. The next cold start uses the new egress; browser login state is
+   * preserved across it. Other typed errors: the validation vocabulary
+   * (`INVALID_PROXY_SERVER`, `PROXY_AUTH_INCOMPLETE`,
+   * `PROXY_SERVER_FORBIDDEN_TARGET`, …), `EDGE_DELETING` (409), and
+   * `SECRETBOX_UNCONFIGURED` (503 — server cannot store credentials safely),
+   * and `EDGE_PROFILE_PROXY_STALE` (409 — expectedVersion lost a tab race).
+   */
+  async setEdgeProfileProxy(orgId, edgeId, profileName, req, expectedVersion) {
+    return this.request("PUT", ENDPOINTS.ORG_EDGE_PROFILE_PROXY(orgId, edgeId, profileName), req, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"proxy-${expectedVersion}"` } : void 0
+    });
+  }
+  /**
+   * Clear the profile's egress proxy; the next pod start egresses directly.
+   * Idle-only like set — 409 `EDGE_PROFILE_IN_USE` while the browser is live.
+   */
+  async clearEdgeProfileProxy(orgId, edgeId, profileName, expectedVersion) {
+    return this.request("DELETE", ENDPOINTS.ORG_EDGE_PROFILE_PROXY(orgId, edgeId, profileName), void 0, void 0, false, {
+      headers: expectedVersion ? { "If-Match": `"proxy-${expectedVersion}"` } : void 0
+    });
+  }
+  /**
+   * Execute a registry clip command on an Edge device.
+   *
+   * A hosted (Cloud Profile) device is reachable ONLY through an explicit
+   * `connection` (id `ccn_…` or alias) — there is no implicit route to an
+   * org-shared browser login. BYOC keeps its legacy selectors (`edge_id`, or
+   * nothing for the caller's own online device).
+   *
+   * Returns the result envelope on completion (`success` may be false when the
+   * command RAN and failed — `error`/`error_code` describe why). Everything
+   * else throws a typed {@link ApiError}; match on `err.code`:
+   *
+   * Safe to retry (guaranteed nothing was dispatched):
+   * - `EDGE_ACTIVATING` 503 + `Retry-After` — cold cloud profile is starting.
+   *   Bounded backoff, same `correlation_id` across the loop.
+   * - `EDGE_BUSY` 409 — the device is executing another request.
+   * - `EDGE_CONCURRENCY_LIMIT` 429 — org at its concurrent-session limit.
+   * - `EDGE_UNAVAILABLE` 503 — session torn down / replaced mid-dispatch.
+   *
+   * NOT retryable:
+   * - `OUTCOME_UNKNOWN` 504 — dispatched, but no result arrived. The command
+   *   MAY HAVE EXECUTED (posted, ordered, deleted…). Never retry
+   *   automatically: verify the effect first, then decide. The message carries
+   *   the request id for audit.
+   * - `EDGE_DEADLINE_EXCEEDED` 504 — arrived late, provably NOT executed.
+   * - `EDGE_HOSTED_DISABLED_FOR_ORG` 403, `EDGE_REPAIR` 503 (operator-held),
+   *   `EDGE_RUNTIME_UNAVAILABLE` 503 (deployment has no hosted runtime).
+   * - Routing errors: `HOSTED_CONNECTION_REQUIRED`, `CONNECTION_NOT_FOUND`,
+   *   `CONNECTION_CLIP_MISMATCH`, `CONNECTION_TARGET_GONE`,
+   *   `CONNECTION_PROFILE_MISMATCH`, `EDGE_DELETING`, `DEVICE_OFFLINE`.
+   */
+  async execEdgeClip(orgId, req) {
+    const t = req.timeout;
+    const serverTimeout = t !== void 0 && t > 0 && t <= 12e4 ? t : 3e4;
+    const timeoutMs = serverTimeout + 1e4;
+    try {
+      return await this.request("POST", ENDPOINTS.ORG_EDGE_EXEC(orgId), req, void 0, false, {
+        timeoutMs
+      });
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 422 && !err.code && typeof err.extras?.error_code === "string") {
+        err.code = err.extras.error_code;
+      }
+      throw err;
+    }
+  }
   // ---- Clip connections ----
   async listClipConnections(orgId, clipId) {
     return this.request("GET", ENDPOINTS.CLIP_CONNECTIONS(orgId, clipId));
@@ -53649,6 +53822,8 @@ var ApiError = class extends Error {
   status;
   code;
   extras;
+  /** Retry-After delta seconds when the server supplies one. */
+  retryAfterSeconds;
   /** Attempted action (authorization denials) — e.g. "chat.add_member". */
   action;
   /** Target resource URI that was evaluated — e.g. "prll://cht_…". */
@@ -53668,6 +53843,9 @@ function buildApiError(res, rawErrorBody) {
   const errMsg = (typeof errorObj?.message === "string" ? errorObj.message : void 0) ?? (typeof errorBody.message === "string" ? errorBody.message : void 0) ?? (typeof errorBody.error === "string" ? errorBody.error : void 0);
   const errCode = (typeof errorObj?.code === "string" ? errorObj.code : void 0) ?? (typeof errorBody.code === "string" ? errorBody.code : void 0);
   const apiError = new ApiError(res.status, errMsg ?? res.statusText, errCode);
+  const retryAfter = Number(res.headers?.get("Retry-After"));
+  if (Number.isFinite(retryAfter) && retryAfter > 0)
+    apiError.retryAfterSeconds = retryAfter;
   const anchors = errorObj ?? errorBody;
   if (typeof anchors.action === "string")
     apiError.action = anchors.action;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/parall",
-  "version": "1.47.0",
+  "version": "1.49.0",
   "description": "OpenClaw channel plugin for Parall IM",
   "license": "MIT",
   "repository": {
@@ -16,8 +16,8 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.47.0",
-    "@parall/sdk": "1.47.0"
+    "@parall/agent-core": "1.49.0",
+    "@parall/sdk": "1.49.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/skills/parall-clips/SKILL.md

@@ -25,6 +25,27 @@ parall clip invoke github-tools list-repos '{"org":"acme"}'
 
 Results are JSON on stdout; failures print an error.
 
+## Execute on an Edge device (registry clips)
+
+Registry clips run on an Edge — a member's desktop, or an org-shared cloud
+profile. **Name the target explicitly.** A cloud profile has NO implicit
+route; omitting the target entirely is a desktop-only legacy form that
+reaches just YOUR OWN online desktop device — never a shared cloud profile.
+
+```bash
+parall clip exec <clip> <command> [args] --connection <id|alias>  # the normal form
+parall clip exec browser-tools screenshot '{"url":"…"}' --connection cloud-main
+```
+
+- A cloud (hosted) profile is reachable ONLY via `--connection` — the clip
+  connection its maintainer bound (`ccn_…` id or alias). That binding IS your
+  authorization; without one the server answers `HOSTED_CONNECTION_REQUIRED`
+  and the fix is to ask an owner/admin to bind the clip, never to retry.
+- `--edge <edgeId>` targets only a desktop device YOU own.
+- Cold cloud profiles are handled by the CLI: it absorbs `EDGE_ACTIVATING`
+  with a bounded wait (~60s) while the profile starts. If the command still
+  fails, report the error — do not blind-retry in a loop.
+
 ## Behavior rules
 
 - An authorization error (clip not bound to you) is a fail-fast: ask the
@@ -34,6 +55,12 @@ Results are JSON on stdout; failures print an error.
 - Hosted browser activation is handled by the CLI: it waits (bounded) while a
   cold hosted browser starts, so if the invoke still fails, report the error —
   do not blind-retry in a loop.
+- **`OUTCOME_UNKNOWN` is never retryable.** It means the command was
+  dispatched and MAY HAVE EXECUTED even though no result came back. Retrying
+  could post, order or delete twice. Verify the effect through the system you
+  acted on (or tell the human, quoting the request id from the error) before
+  ever re-running. `EDGE_BUSY` is the opposite: guaranteed-unexecuted — wait
+  briefly, then one retry is safe.
 - A clip may act through a person's real logged-in account — outward,
   irreversible, or spending actions (post, order, delete, pay) get the same
   caution as any shared-state change: confirm when intent isn't explicit.

package/skills/parall-tasks/SKILL.md

@@ -39,7 +39,7 @@ parall tasks list --assignee-id prll://usr_xxx   # first page only (default 20)
 parall tasks subtasks prll://tsk_xxx             # children of a single parent task
 
 # Create a task (add --parent-id to make it a SUBTASK of another task)
-parall tasks create --title "Task title" [--assignee-id prll://usr_xxx] [--parent-id prll://tsk_xxx] [--project-id prll://prj_xxx] [--due-date 2026-08-01]
+parall tasks create --title "Task title" [--assignee-id prll://usr_xxx] [--parent-id prll://tsk_xxx] [--project-id prll://prj_xxx] [--planned-start 2026-07-20] [--due-date 2026-08-01]
 
 # Update task status — add --placement end so the task lands at the end of
 # its NEW status column (a bare --status keeps the old column's sort_order)
@@ -50,6 +50,12 @@ parall tasks update prll://tsk_xxx --status done --placement end
 parall tasks update prll://tsk_xxx --due-date 2026-08-01
 parall tasks update prll://tsk_xxx --due-date none
 
+# Planned start — same grammar as --due-date; must be on or before the due
+# date when both are set. This is the planned schedule's left-edge date,
+# NOT when work actually began (that stays on lifecycle timestamps)
+parall tasks update prll://tsk_xxx --planned-start 2026-07-20
+parall tasks update prll://tsk_xxx --planned-start none
+
 # Move a task to the end of its status column
 parall tasks update prll://tsk_xxx --placement end