@parall/cli 1.47.0 → 1.49.0

package/dist/commands/clip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../src/commands/clip.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+BpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QA0JpD"}
+{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../src/commands/clip.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgCpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QA4OpD"}

package/dist/commands/clip.js

@@ -1,6 +1,7 @@
 import { resolveCredentials } from '../lib/client.js';
 import { invokeClipAwaitingActivation } from '../lib/clip-invoke.js';
-import { printJson, printError } from '../lib/output.js';
+import { execEdgeClipAwaitingActivation } from '../lib/edge-exec.js';
+import { printJson, printError, parsePositiveInt } from '../lib/output.js';
 /**
  * Derive a CLI-friendly alias from a registry source string.
  * Handles scoped packages ("@scope/name@1.0.0" → "name") and
@@ -159,6 +160,66 @@ export function registerClipCommands(program) {
             printError(err);
         }
     });
+    clip
+        .command('exec')
+        .description('Execute a registry (Edge) clip command on an Edge device. A cloud (hosted) profile is reachable ONLY via --connection; with neither --connection nor --edge, the server resolves just your OWN online desktop device (legacy BYOC fallback — never a cloud profile)')
+        .argument('<clip>', 'Clip name in the org clip registry')
+        .argument('<command>', 'Command name to execute')
+        .argument('[args]', 'Command arguments (JSON string or plain text)')
+        .option('--connection <ref>', 'Clip connection id (ccn_…) or alias. REQUIRED to reach a cloud (hosted) profile — the binding its maintainer created is the authorization')
+        .option('--edge <edgeId>', 'A desktop (BYOC) device you own. Mutually exclusive with --connection')
+        .option('--profile <name>', 'Browser profile (with --connection it may only restate the granted one)')
+        .option('--timeout <ms>', 'Execution timeout in milliseconds', '30000')
+        .action(async (clipName, command, args, opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            let parsedArgs;
+            if (args !== undefined) {
+                try {
+                    parsedArgs = JSON.parse(args);
+                }
+                catch {
+                    parsedArgs = args;
+                }
+            }
+            // Strict grammar, validated BEFORE the wire: parseInt would accept
+            // "5000ms" or "1.5", and the server silently replaces an out-of-range
+            // timeout with its 30s default — so a malformed flag would run with a
+            // deadline the caller never asked for. printError never returns.
+            let timeoutMs;
+            if (opts?.timeout) {
+                timeoutMs = parsePositiveInt(opts.timeout);
+                if (timeoutMs === undefined || timeoutMs > 120_000) {
+                    printError(new Error('--timeout must be an integer between 1 and 120000 (milliseconds)'));
+                }
+            }
+            const req = {
+                clip: clipName,
+                command,
+                args: parsedArgs,
+                connection: opts?.connection,
+                edge_id: opts?.edge,
+                profile: opts?.profile,
+                timeout: timeoutMs,
+            };
+            // A cold cloud profile answers 503 EDGE_ACTIVATING BEFORE anything is
+            // dispatched; absorb that one retryable window here (bounded, one
+            // correlation id) instead of making every agent hand-roll a loop.
+            // Everything else — OUTCOME_UNKNOWN above all — propagates untouched:
+            // a dispatched command may have executed, and retrying it is not this
+            // tool's call. See lib/edge-exec.ts.
+            const result = await execEdgeClipAwaitingActivation(client, orgId, req);
+            if (result.success) {
+                printJson(result.data ?? null);
+            }
+            else {
+                printError(new Error(result.error ?? 'execution failed'));
+            }
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
     clip
         .command('remove')
         .description('Remove a clip by alias')

package/dist/commands/comments.d.ts

@@ -1,4 +1,20 @@
 import { Command } from 'commander';
+/**
+ * Decide how `comments list` addresses its target. A wiki file URI without an
+ * anchor lists by PREFIX so inline anchored comments
+ * (`prll://wik_x/path.md?rev=<sha>#h=...`) are returned alongside page-level
+ * ones — the server matches `prefix` OR `prefix?%` OR `prefix#%`. Everything
+ * else (task/message targets, wiki roots, changesets, and wiki URIs that carry
+ * an explicit `?rev`/`#` anchor) keeps exact `target_uri` matching, as does
+ * `--exact`. Exported for tests.
+ */
+export declare function buildListTarget(target: string, opts?: {
+    exact?: boolean;
+}): {
+    target_uri: string;
+} | {
+    target_prefix: string;
+};
 /**
  * Generic, target-agnostic comment commands over `POST/GET/PATCH/DELETE
  * /comments`. Unlike `parall tasks comments` (task-only) and `parall wiki

package/dist/commands/comments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../src/commands/comments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAoGvD"}
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../src/commands/comments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2BpC;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GACzB;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAMpD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAsHvD"}

package/dist/commands/comments.js

@@ -10,6 +10,34 @@ function stripUndefined(obj) {
 function normalizeTarget(target) {
     return target.startsWith('prll://') ? target : `prll://${target}`;
 }
+// A wiki FILE URI with no explicit anchor: `prll://wik_<id>/<path>` carrying
+// no query (`?rev=`) and no fragment (`#h=` / `#l=`). Wiki roots (`prll://wik_x`,
+// `prll://wik_x/`) and directory-ish paths (trailing slash) don't qualify — the
+// server's target_prefix ACL only accepts file-scope prefixes.
+function isWikiFileUriWithoutAnchor(uri) {
+    if (!uri.startsWith('prll://wik_'))
+        return false;
+    if (uri.includes('?') || uri.includes('#'))
+        return false;
+    const path = uri.slice('prll://'.length).split('/').slice(1).join('/');
+    return path !== '' && !path.endsWith('/');
+}
+/**
+ * Decide how `comments list` addresses its target. A wiki file URI without an
+ * anchor lists by PREFIX so inline anchored comments
+ * (`prll://wik_x/path.md?rev=<sha>#h=...`) are returned alongside page-level
+ * ones — the server matches `prefix` OR `prefix?%` OR `prefix#%`. Everything
+ * else (task/message targets, wiki roots, changesets, and wiki URIs that carry
+ * an explicit `?rev`/`#` anchor) keeps exact `target_uri` matching, as does
+ * `--exact`. Exported for tests.
+ */
+export function buildListTarget(target, opts) {
+    const uri = normalizeTarget(target);
+    if (!opts?.exact && isWikiFileUriWithoutAnchor(uri)) {
+        return { target_prefix: uri };
+    }
+    return { target_uri: uri };
+}
 /**
  * Generic, target-agnostic comment commands over `POST/GET/PATCH/DELETE
  * /comments`. Unlike `parall tasks comments` (task-only) and `parall wiki
@@ -23,7 +51,8 @@ export function registerCommentCommands(program) {
         .description('Manage comments on any prll:// target (task / wiki page / changeset / inline anchor)');
     comments
         .command('add')
-        .description('Add a comment to a prll:// target')
+        .description('Add a comment to a prll:// target. Inline wiki anchors must pin a revision: ' +
+        'prll://wik_x/path.md?rev=<full_commit_sha>#h=<anchor>')
         .requiredOption('--target <uri>', 'Target prll:// URI (task / wiki page / changeset / inline anchor)')
         .requiredOption('--body <text>', 'Comment body')
         .option('--parent <id>', 'Parent comment ID (task comments only — threaded reply)')
@@ -44,11 +73,16 @@ export function registerCommentCommands(program) {
     });
     comments
         .command('list')
-        .description('List comments on a prll:// target')
+        .description('List comments on a prll:// target. For a wiki file URI without an anchor ' +
+        '(prll://wik_x/path.md), inline anchored comments on that file ' +
+        '(...path.md?rev=<sha>#h=...) are included — each row carries its own ' +
+        'target_uri so anchored rows are distinguishable. Use --exact to list ' +
+        'only comments whose target matches the URI exactly.')
         .requiredOption('--target <uri>', 'Target prll:// URI')
         .option('--limit <n>', 'Maximum number of comments to return', '50')
         .option('--cursor <cursor>', 'Pagination cursor')
         .option('--order <order>', 'Sort order (asc or desc)')
+        .option('--exact', 'Match the target URI exactly (exclude inline anchored comments)')
         .action(async (opts) => {
         try {
             const { client, orgId } = resolveCredentials();
@@ -58,7 +92,7 @@ export function registerCommentCommands(program) {
                 order: opts.order,
             });
             const result = await client.getComments(orgId, {
-                target_uri: normalizeTarget(opts.target),
+                ...buildListTarget(opts.target, { exact: opts.exact }),
                 ...params,
             });
             printJson(result);

package/dist/commands/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/commands/messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBzC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAuOvD"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/commands/messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBzC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAsPvD"}

package/dist/commands/messages.js

@@ -51,6 +51,21 @@ export function registerMessageCommands(program) {
             printError(err);
         }
     });
+    messages
+        .command('react')
+        .description('Toggle an emoji reaction on a message (add if absent, remove if present)')
+        .argument('<messageId>', 'Message ID')
+        .argument('<emoji>', 'Emoji to toggle (e.g. 👍)')
+        .action(async (messageId, emoji) => {
+        try {
+            const { client } = resolveCredentials();
+            const result = await client.toggleReaction(stripPrllScheme(messageId), emoji);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
     messages
         .command('send')
         .description('Send a message to a chat (text, file, or both)')

package/dist/commands/refs.d.ts

@@ -1,4 +1,12 @@
-import { Command } from 'commander';
+import type { Command } from 'commander';
+/**
+ * Resolve cross-chat authority as explicit --from, then runtime trigger, then
+ * none. --strict forces none and cannot be combined with --from; non-message
+ * runtime triggers are never accepted as message authority.
+ */
+export declare function buildResolveRefsOptions(explicitFrom: string | undefined, triggerMessageId: string | undefined, strict?: boolean): {
+    sourceMessageId: string;
+} | undefined;
 /** Build the SDK ref-graph params from the positional URI + CLI flags. */
 export declare function buildRefGraphParams(uri: string, opts: {
     depth?: string;

package/dist/commands/refs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/commands/refs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,0EAA0E;AAC1E,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACvB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAOjC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,QA+DnD"}
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/commands/refs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUzC;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,MAAM,UAAQ,GACb;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAqBzC;AAED,0EAA0E;AAC1E,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACvB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAOjC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,QAsEnD"}

package/dist/commands/refs.js

@@ -1,5 +1,33 @@
-import { resolveCredentials } from '../lib/client.js';
-import { ensurePrllScheme, parsePositiveInt, printError, printJson } from '../lib/output.js';
+import { resolveCredentials, resolveRuntimeContext } from '../lib/client.js';
+import { ensurePrllScheme, parsePositiveInt, printError, printJson, stripPrllScheme, } from '../lib/output.js';
+/**
+ * Resolve cross-chat authority as explicit --from, then runtime trigger, then
+ * none. --strict forces none and cannot be combined with --from; non-message
+ * runtime triggers are never accepted as message authority.
+ */
+export function buildResolveRefsOptions(explicitFrom, triggerMessageId, strict = false) {
+    const explicit = explicitFrom?.trim();
+    if (strict && explicit) {
+        throw new Error('--strict cannot be combined with --from');
+    }
+    if (strict)
+        return undefined;
+    if (explicit) {
+        const sourceMessageId = stripPrllScheme(explicit);
+        if (!sourceMessageId.startsWith('msg_')) {
+            throw new Error('--from must be a message ID (msg_...) or prll://msg_... URI');
+        }
+        return { sourceMessageId };
+    }
+    // Typed task dispatches can carry a task ID in trigger_message_id. Only a
+    // real message can grant the server's cross-chat reference access; omitting
+    // non-message triggers preserves the normal membership-filtered resolve.
+    const trigger = triggerMessageId?.trim();
+    if (!trigger)
+        return undefined;
+    const sourceMessageId = stripPrllScheme(trigger);
+    return sourceMessageId.startsWith('msg_') ? { sourceMessageId } : undefined;
+}
 /** Build the SDK ref-graph params from the positional URI + CLI flags. */
 export function buildRefGraphParams(uri, opts) {
     const params = { uri: ensurePrllScheme(uri) };
@@ -15,10 +43,13 @@ export function registerRefCommands(program) {
     refs
         .command('resolve <uris...>')
         .description('Batch resolve prll:// URIs to entity metadata')
-        .action(async (uris) => {
+        .option('--from <messageId>', 'Forwarding message for cross-chat access (defaults to trigger)')
+        .option('--strict', 'Ignore runtime trigger and enforce direct membership checks')
+        .action(async (uris, opts) => {
         try {
             const { client, orgId } = resolveCredentials();
-            const result = await client.resolveRefs(orgId, uris);
+            const runtime = resolveRuntimeContext();
+            const result = await client.resolveRefs(orgId, uris, buildResolveRefsOptions(opts.from, runtime.triggerMessageId, opts.strict));
             printJson(result);
         }
         catch (err) {

package/dist/commands/tasks.d.ts

@@ -10,6 +10,7 @@ export declare function buildCreateTaskData(opts: {
     parentId?: string;
     sourceChatId?: string;
     dueDate?: string;
+    plannedStart?: string;
 }): Partial<{
     title: string;
     description: string | undefined;
@@ -19,6 +20,7 @@ export declare function buildCreateTaskData(opts: {
     project_id: string | undefined;
     parent_id: string | undefined;
     source_chat_id: string | undefined;
+    planned_start_date: string | undefined;
     due_date: string | undefined;
 }>;
 export declare function buildUpdateTaskData(opts: {
@@ -32,6 +34,7 @@ export declare function buildUpdateTaskData(opts: {
     sortOrder?: string;
     placement?: string;
     dueDate?: string;
+    plannedStart?: string;
 }): Partial<{
     title: string | undefined;
     status: UpdateTaskRequest["status"];
@@ -42,6 +45,7 @@ export declare function buildUpdateTaskData(opts: {
     parent_id: string | undefined;
     sort_order: number | undefined;
     placement: "end" | undefined;
+    planned_start_date: string | null | undefined;
     due_date: string | null | undefined;
 }>;
 export declare function registerTaskCommands(program: Command): void;

package/dist/commands/tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/commands/tasks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8DpC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;;;;;;;;;;GAYA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;;YAS0B,iBAAiB,CAAC,QAAQ,CAAC;cACvB,iBAAiB,CAAC,UAAU,CAAC;;;;;;;;GAS3D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAiWpD"}
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/commands/tasks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgEpC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;;;;;;;;;;;GAaA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;;YAS0B,iBAAiB,CAAC,QAAQ,CAAC;cACvB,iBAAiB,CAAC,UAAU,CAAC;;;;;;;;;GAU3D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAyWpD"}

package/dist/commands/tasks.js

@@ -10,26 +10,28 @@ function stripUndefined(obj) {
 // intent into a successful no-op. The server independently re-validates and
 // stays authoritative for domain semantics (calendar validity, placement
 // set, ordering conflicts, permissions).
-/** Strict command grammar for --due-date; calendar validity (e.g. 2026-02-30)
- * stays the server's domain (400 INVALID_DUE_DATE). */
-const DUE_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-function resolveCreateDueDate(value) {
+/** Strict command grammar for the date flags (--due-date, --planned-start);
+ * calendar validity (e.g. 2026-02-30) and the cross-field ordering rule
+ * (planned start <= due) stay the server's domain (400 INVALID_DUE_DATE /
+ * INVALID_PLANNED_START_DATE / INVALID_DATE_RANGE). */
+const DATE_FLAG_RE = /^\d{4}-\d{2}-\d{2}$/;
+function resolveCreateDateFlag(flag, value) {
     if (value === undefined)
         return undefined;
-    if (!DUE_DATE_RE.test(value)) {
-        throw new Error('--due-date must be a YYYY-MM-DD date');
+    if (!DATE_FLAG_RE.test(value)) {
+        throw new Error(`${flag} must be a YYYY-MM-DD date`);
     }
     return value;
 }
 /** Update grammar adds the lowercase "none" sentinel — the agent-facing
  * clear intent, mapped to an explicit null on the wire. */
-function resolveUpdateDueDate(value) {
+function resolveUpdateDateFlag(flag, value) {
     if (value === undefined)
         return undefined;
     if (value === 'none')
         return null;
-    if (!DUE_DATE_RE.test(value)) {
-        throw new Error('--due-date must be a YYYY-MM-DD date, or "none" to clear it');
+    if (!DATE_FLAG_RE.test(value)) {
+        throw new Error(`${flag} must be a YYYY-MM-DD date, or "none" to clear it`);
     }
     return value;
 }
@@ -67,7 +69,8 @@ export function buildCreateTaskData(opts) {
         project_id: opts.projectId ? stripPrllScheme(opts.projectId) : undefined,
         parent_id: opts.parentId ? stripPrllScheme(opts.parentId) : undefined,
         source_chat_id: opts.sourceChatId ? stripPrllScheme(opts.sourceChatId) : undefined,
-        due_date: resolveCreateDueDate(opts.dueDate),
+        planned_start_date: resolveCreateDateFlag('--planned-start', opts.plannedStart),
+        due_date: resolveCreateDateFlag('--due-date', opts.dueDate),
     });
 }
 export function buildUpdateTaskData(opts) {
@@ -87,7 +90,8 @@ export function buildUpdateTaskData(opts) {
         parent_id: opts.parentId ? stripPrllScheme(opts.parentId) : undefined,
         sort_order: resolveSortOrder(opts.sortOrder),
         placement: resolvePlacement(opts.placement),
-        due_date: resolveUpdateDueDate(opts.dueDate),
+        planned_start_date: resolveUpdateDateFlag('--planned-start', opts.plannedStart),
+        due_date: resolveUpdateDateFlag('--due-date', opts.dueDate),
     });
 }
 export function registerTaskCommands(program) {
@@ -136,6 +140,7 @@ export function registerTaskCommands(program) {
         .option('--project-id <id>', 'Project ID')
         .option('--parent-id <id>', 'Parent task ID')
         .option('--source-chat-id <id>', 'Source chat ID')
+        .option('--planned-start <date>', 'Planned start date (YYYY-MM-DD) — must be on or before --due-date when both are set')
         .option('--due-date <date>', 'Planned completion date (YYYY-MM-DD)')
         .action(async (opts) => {
         try {
@@ -178,6 +183,7 @@ export function registerTaskCommands(program) {
         .option('--parent-id <id>', 'Parent task ID')
         .option('--sort-order <n>', 'Explicit sort_order value — only for pinpoint insertion relative to cards you can see; to append to a status column use --placement end')
         .option('--placement <where>', 'Ordering intent — only "end" is accepted: appends the task to the end of its status column, position resolved by the server (mutually exclusive with --sort-order)')
+        .option('--planned-start <date>', 'Planned start date (YYYY-MM-DD), or "none" to clear it — must be on or before the due date when both are set')
         .option('--due-date <date>', 'Planned completion date (YYYY-MM-DD), or "none" to clear it')
         .action(async (taskId, opts) => {
         try {

package/dist/lib/edge-exec.d.ts

@@ -0,0 +1,55 @@
+import type { EdgeClipExecResult, ExecEdgeClipRequest, ParallClient } from '@parall/sdk';
+/**
+ * Cloud (hosted) Edge activation wait — CLI-side bounded retry for `clip exec`.
+ *
+ * A clip connection bound to a `placement=hosted` Edge whose pod is cold returns
+ * 503 EDGE_ACTIVATING from the exec pre-flight: the platform is starting the
+ * pod, and the command has NOT been dispatched (the server answers before any
+ * publish), so retrying the identical request cannot double-execute anything.
+ * This module absorbs that one precise error so a single `parall clip exec`
+ * rides through cold start instead of forcing the caller (agent or human) into
+ * a blind retry loop.
+ *
+ * Everything else propagates on first occurrence — especially OUTCOME_UNKNOWN
+ * (504): the command was dispatched and MAY HAVE EXECUTED; an automatic retry
+ * could post, order or delete twice. That decision belongs to the caller, with
+ * the request id from the error message, never to a loop in here.
+ *
+ * Deliberately NOT in the SDK: `execEdgeClip()` keeps its throw-on-503
+ * semantics for every other consumer; only the CLI exec behavior waits.
+ * Mirrors lib/clip-invoke.ts (the v2 hosted-browser wait) — same budget, same
+ * schedule, same exact-code matching discipline.
+ */
+/** Total activation wait budget. Independent of the clip command --timeout:
+ *  each attempt keeps its own full command timeout, so worst-case wall clock is
+ *  roughly this budget plus one command timeout. */
+export declare const EDGE_ACTIVATION_WAIT_BUDGET_MS = 60000;
+/** Backoff schedule between activation retries; the last entry repeats. */
+export declare const EDGE_ACTIVATION_BACKOFF_MS: number[];
+/** Injectable time hooks so tests never really sleep. */
+export type EdgeActivationWaitHooks = {
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+};
+/**
+ * The ONLY retryable error: a typed ApiError carrying exactly 503 +
+ * EDGE_ACTIVATING. Everything else — routing errors, EDGE_BUSY, capacity,
+ * repair, command failures, timeouts, OUTCOME_UNKNOWN, other 5xx — means
+ * retrying is either pointless or unsafe, so it propagates unchanged on the
+ * first occurrence.
+ */
+export declare function isEdgeActivationPending(err: unknown): boolean;
+/**
+ * Execute an Edge clip, transparently absorbing the cloud-profile activation
+ * window.
+ *
+ * Retries the IDENTICAL request while the server reports EDGE_ACTIVATING,
+ * backing off 500ms → 1s → 2s (capped) until the 60s activation budget is
+ * spent. The whole loop carries one `correlation_id` (the caller's, or one
+ * minted here) so the server's exec audit reads the retries as a single
+ * logical call. Once the budget is spent, the LAST typed ApiError is rethrown
+ * as-is — status/code intact — so the printed error stays machine-readable.
+ * Any other failure is rethrown immediately.
+ */
+export declare function execEdgeClipAwaitingActivation(client: Pick<ParallClient, 'execEdgeClip'>, orgId: string, req: ExecEdgeClipRequest, hooks?: EdgeActivationWaitHooks): Promise<EdgeClipExecResult>;
+//# sourceMappingURL=edge-exec.d.ts.map

package/dist/lib/edge-exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-exec.d.ts","sourceRoot":"","sources":["../../src/lib/edge-exec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGzF;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;oDAEoD;AACpD,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAErD,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B,UAAsB,CAAC;AAE9D,yDAAyD;AACzD,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAIF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,cAAc,CAAC,EAC1C,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,mBAAmB,EACxB,KAAK,CAAC,EAAE,uBAAuB,GAC9B,OAAO,CAAC,kBAAkB,CAAC,CAuB7B"}

package/dist/lib/edge-exec.js

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto';
+import { ApiError } from '@parall/sdk';
+/**
+ * Cloud (hosted) Edge activation wait — CLI-side bounded retry for `clip exec`.
+ *
+ * A clip connection bound to a `placement=hosted` Edge whose pod is cold returns
+ * 503 EDGE_ACTIVATING from the exec pre-flight: the platform is starting the
+ * pod, and the command has NOT been dispatched (the server answers before any
+ * publish), so retrying the identical request cannot double-execute anything.
+ * This module absorbs that one precise error so a single `parall clip exec`
+ * rides through cold start instead of forcing the caller (agent or human) into
+ * a blind retry loop.
+ *
+ * Everything else propagates on first occurrence — especially OUTCOME_UNKNOWN
+ * (504): the command was dispatched and MAY HAVE EXECUTED; an automatic retry
+ * could post, order or delete twice. That decision belongs to the caller, with
+ * the request id from the error message, never to a loop in here.
+ *
+ * Deliberately NOT in the SDK: `execEdgeClip()` keeps its throw-on-503
+ * semantics for every other consumer; only the CLI exec behavior waits.
+ * Mirrors lib/clip-invoke.ts (the v2 hosted-browser wait) — same budget, same
+ * schedule, same exact-code matching discipline.
+ */
+/** Total activation wait budget. Independent of the clip command --timeout:
+ *  each attempt keeps its own full command timeout, so worst-case wall clock is
+ *  roughly this budget plus one command timeout. */
+export const EDGE_ACTIVATION_WAIT_BUDGET_MS = 60_000;
+/** Backoff schedule between activation retries; the last entry repeats. */
+export const EDGE_ACTIVATION_BACKOFF_MS = [500, 1_000, 2_000];
+const realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * The ONLY retryable error: a typed ApiError carrying exactly 503 +
+ * EDGE_ACTIVATING. Everything else — routing errors, EDGE_BUSY, capacity,
+ * repair, command failures, timeouts, OUTCOME_UNKNOWN, other 5xx — means
+ * retrying is either pointless or unsafe, so it propagates unchanged on the
+ * first occurrence.
+ */
+export function isEdgeActivationPending(err) {
+    return err instanceof ApiError && err.status === 503 && err.code === 'EDGE_ACTIVATING';
+}
+/**
+ * Execute an Edge clip, transparently absorbing the cloud-profile activation
+ * window.
+ *
+ * Retries the IDENTICAL request while the server reports EDGE_ACTIVATING,
+ * backing off 500ms → 1s → 2s (capped) until the 60s activation budget is
+ * spent. The whole loop carries one `correlation_id` (the caller's, or one
+ * minted here) so the server's exec audit reads the retries as a single
+ * logical call. Once the budget is spent, the LAST typed ApiError is rethrown
+ * as-is — status/code intact — so the printed error stays machine-readable.
+ * Any other failure is rethrown immediately.
+ */
+export async function execEdgeClipAwaitingActivation(client, orgId, req, hooks) {
+    const sleep = hooks?.sleep ?? realSleep;
+    const now = hooks?.now ?? Date.now;
+    const pinned = {
+        ...req,
+        correlation_id: req.correlation_id ?? randomUUID(),
+    };
+    const deadline = now() + EDGE_ACTIVATION_WAIT_BUDGET_MS;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await client.execEdgeClip(orgId, pinned);
+        }
+        catch (err) {
+            if (!isEdgeActivationPending(err))
+                throw err;
+            const remaining = deadline - now();
+            if (remaining <= 0)
+                throw err;
+            const backoff = EDGE_ACTIVATION_BACKOFF_MS[Math.min(attempt, EDGE_ACTIVATION_BACKOFF_MS.length - 1)];
+            // Clamp to the remaining budget so the final sleep can't overrun it.
+            await sleep(Math.min(backoff, remaining));
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/cli",
-  "version": "1.47.0",
+  "version": "1.49.0",
   "description": "CLI client for Parall — universal agent & human access to Parall API",
   "license": "MIT",
   "repository": {
@@ -36,14 +36,14 @@
     "diff": "^8.0.3",
     "js-yaml": "^4.1.0",
     "zod": "^4.3.6",
-    "@parall/agent-core": "1.47.0",
-    "@parall/sdk": "1.47.0"
+    "@parall/agent-core": "1.49.0",
+    "@parall/sdk": "1.49.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0",
-    "@parall/agent-core": "1.47.0"
+    "@parall/agent-core": "1.49.0"
   },
   "scripts": {
     "build": "tsc",