@floomhq/signaldash 0.39.7 → 0.39.9

package/README.md

@@ -120,7 +120,7 @@ setup installs both from the same pinned npm package
 the human chose to execute:
 
 ```bash
-npx -y @floomhq/signaldash@0.39.7 <invite-code>
+npx -y @floomhq/signaldash@0.39.9 <invite-code>
 ```
 
 Run that command in a terminal, not in an agent chat. Do not ask an agent to
@@ -192,12 +192,17 @@ SignalDash exposes:
 - `li_my_posts(limit, member_id)`
 - `li_post_reactions(post_id, limit, cursor?)`
 - `li_post_comments(post_id, comment_id?, resolve_reply_state?, limit, cursor?)`
-- `li_reply_to_comment(post_id?, parent_comment_id?, trigger_comment_id?, text?, expected_watermark?, secretary_receipt_id?)`
+- `li_reply_to_comment(post_id?, parent_comment_id?, trigger_comment_id?, text?, mentions?, expected_watermark?, secretary_receipt_id?)`
 - `li_like_comment(post_id, parent_comment_id, comment_id, expected_watermark?)`
 - `li_delete_message(chat_id, message_id, confirm)`
 - `li_delete_comment(post_id, comment_id, confirm)`
 - `li_draft_post(text, publish, scheduled_at?, content_pipeline_id?, content_pipeline_override?, mentions?, attachments?, first_comment?)`
 - `li_set_scheduled_post_first_comment(id, first_comment, confirm)`
+- `li_save_post_draft(text, mentions?, attachments?, first_comment?, source_key?, metadata?)`
+- `li_post_drafts()`
+- `li_update_post_draft(id, text, expected_version, mentions?, attachments?, first_comment?)`
+- `li_delete_post_draft(id, expected_version, confirm)`
+- `li_post_draft_preview(id)`
 - `li_scheduled_posts()`
 - `li_scheduled_post_preview(id)`
 - `li_edit_scheduled_post(id, text, scheduled_at, mentions?, attachments?, first_comment?, confirm?, approval_hash?, expected_version?, expected_updated_at?)`
@@ -379,6 +384,35 @@ uses the same sender binding, action ledger, duplicate guard, daily budget, and
 provider-warning lock as immediate publishing. An interrupted or ambiguous
 execution fails closed and is never retried automatically.
 
+Arbitrary saved LinkedIn drafts use a separate durable store and never enter
+the scheduling or publishing worker. `li_save_post_draft` stores exact text,
+up to 25 mentions, up to 20 ordered images, and an optional first comment.
+Each image is limited to 5 MiB and one draft to 12 MiB; each tenant is limited
+to 1,000 drafts and 100 MiB of decoded attachment bytes. Ordinary duplicate
+drafts remain distinct records. Imports may instead supply a tenant-scoped
+`source_key`: an identical replay returns the existing draft, while a replay
+with different content is refused. Bounded structured `metadata` preserves the
+source, title, storyline, readiness, hold gates, editorial notes, visual notes,
+and revision without placing those fields in the publishable post text. List
+responses expose image metadata rather than base64.
+`li_update_post_draft` is a complete compare-and-swap replacement: pass the
+current `expected_version`, and omission clears optional mentions, images, or
+first comment. `li_delete_post_draft` requires the current version and
+`confirm:true`. None of these operations calls LinkedIn, Unipile, Buffer, or an
+action-budget lane.
+
+`li_post_draft_preview` returns a short-lived, one-use
+`https://signaldash.dev/d/<token>` link for one exact saved draft. POSTing its
+confirmation creates a 15-minute cookie restricted to `/drafts`; the page and
+its `/drafts/:id/attachments/:index` media route remain bound to that tenant,
+draft, and originating live SignalDash session. Media is served byte-for-byte
+with `private, no-store`, MIME allowlisting, `nosniff`, and a restrictive CSP.
+The shared calendar displays unscheduled SignalDash and Buffer drafts with the
+same cards as scheduled posts, marked by a visible `DRAFT` tag and an
+`Unscheduled` time label. Saved SignalDash media uses separate protected
+`/calendar/drafts/...` URLs. Drafts never enter the `items` returned by
+`li_scheduled_posts`, preserving its existing calendar contract.
+
 `li_scheduled_posts` is the shared planning read across posts stored by
 SignalDash and the configured Buffer LinkedIn channel. Every item names its
 source, and the response reports independent completeness for SignalDash,

package/bin/sd.mjs

@@ -1564,7 +1564,7 @@ const TOOLS = [
   {
     name: "li_reply_to_comment",
     path: "/li/reply_to_comment",
-    description: "Reply once to one exact inbound comment on the authenticated sender's own LinkedIn post. First read li_post_comments and preserve the exact post_id, parent_comment_id, trigger_comment_id, text, and returned signaldash_watermark. SignalDash re-proves post ownership, trigger identity and content, absence of an own duplicate, sender generation, budget, and provider safety immediately before writing. A 2xx is not success until bounded readback finds exactly one own reply. A Secretary approval uses secretary_receipt_id alone.",
+    description: "Reply once to one exact inbound comment on the authenticated sender's own LinkedIn post. First read li_post_comments and preserve the exact post_id, parent_comment_id, trigger_comment_id, text, and returned signaldash_watermark. Optional mentions tag people in the reply: spell each person's name into text exactly once as a whole word and pass a matching mentions entry, exactly as li_draft_post does. LinkedIn already notifies the comment's author, so a mention is for tagging a THIRD person. SignalDash re-proves post ownership, trigger identity and content, absence of an own duplicate, sender generation, budget, and provider safety immediately before writing. A 2xx is not success until bounded readback finds exactly one own reply whose landed text equals text, so a tag whose display name does not render exactly as written is reported unverified rather than assumed sent. A Secretary approval uses secretary_receipt_id alone.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1572,6 +1572,18 @@ const TOOLS = [
         parent_comment_id: { type: "string", minLength: 1, maxLength: 500 },
         trigger_comment_id: { type: "string", minLength: 1, maxLength: 500 },
         text: { type: "string", minLength: 1, maxLength: 1250 },
+        mentions: {
+          type: "array", maxItems: 20,
+          description: "People to tag. Each name must appear exactly once in text as a whole word; SignalDash replaces that one occurrence with the provider's mention token. Use the person's exact LinkedIn display name, because the landed comment is verified against text character for character.",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", minLength: 1, maxLength: 120 },
+              profile_id: { type: "string", minLength: 1, maxLength: 250 },
+            },
+            required: ["name", "profile_id"],
+          },
+        },
         expected_watermark: { type: "string", pattern: "^[0-9a-f]{64}$" },
         secretary_receipt_id: { type: "string", minLength: 1, maxLength: 500 },
       },
@@ -1689,12 +1701,238 @@ const TOOLS = [
       additionalProperties: false,
     },
   },
+  {
+    name: "li_save_post_draft",
+    path: "/li/save_post_draft",
+    description: "Persist one arbitrary LinkedIn post draft without scheduling or publishing it. Stores exact text, ordered image bytes, mentions, and an optional first comment. Duplicate drafts are allowed. No provider call or action budget is used.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", minLength: 1, maxLength: 3000 },
+        mentions: {
+          type: "array", maxItems: 25,
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", minLength: 1, maxLength: 120 },
+              profile_id: { type: "string", minLength: 1, maxLength: 250 },
+            },
+            required: ["name", "profile_id"],
+            additionalProperties: false,
+          },
+        },
+        attachments: {
+          type: "array", maxItems: 20,
+          items: {
+            type: "object",
+            properties: {
+              filename: { type: "string", minLength: 1, maxLength: 180 },
+              content_type: { type: "string", enum: ["image/png", "image/jpeg", "image/webp", "image/gif"] },
+              content_base64: { type: "string", minLength: 1 },
+            },
+            required: ["filename", "content_type", "content_base64"],
+            additionalProperties: false,
+          },
+        },
+        first_comment: { type: "string", minLength: 1, maxLength: 1250 },
+        source_key: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256,
+          description: "Optional tenant-scoped idempotency key for a durable source item. Reusing it with different content is refused.",
+        },
+        metadata: {
+          type: "object",
+          properties: {
+            source_group: { type: "string", minLength: 1, maxLength: 100 },
+            source_batch_id: { type: "string", minLength: 1, maxLength: 200 },
+            source_item_id: { type: "string", minLength: 1, maxLength: 200 },
+            title: { type: "string", minLength: 1, maxLength: 500 },
+            storyline: { type: "string", minLength: 1, maxLength: 2000 },
+            readiness: { type: "string", enum: ["ready", "held"] },
+            hold_gates: {
+              type: "array",
+              maxItems: 20,
+              items: {
+                type: "object",
+                properties: {
+                  code: { type: "string", minLength: 1, maxLength: 100 },
+                  note: { type: "string", minLength: 1, maxLength: 2000 },
+                },
+                required: ["code", "note"],
+                additionalProperties: false,
+              },
+            },
+            source: {
+              type: "object",
+              properties: {
+                label: { type: "string", minLength: 1, maxLength: 500 },
+                id: { type: "string", minLength: 1, maxLength: 500 },
+                text: { type: "string", minLength: 1, maxLength: 12000 },
+              },
+              additionalProperties: false,
+            },
+            status: { type: "string", minLength: 1, maxLength: 100 },
+            editorial_notes: {
+              type: "array",
+              maxItems: 20,
+              items: { type: "string", minLength: 1, maxLength: 4000 },
+            },
+            visual: { type: "string", minLength: 1, maxLength: 4000 },
+            revision: { type: "integer", minimum: 0 },
+          },
+          additionalProperties: false,
+        },
+      },
+      required: ["text"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_post_drafts",
+    path: "/li/post_drafts",
+    description: "List this account's durable SignalDash LinkedIn post drafts and return a fresh one-use calendar link. Attachment metadata is returned, never base64 bytes. These drafts remain separate from scheduled posts and do not appear in li_scheduled_posts items.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "li_update_post_draft",
+    path: "/li/update_post_draft",
+    description: "Atomically replace one complete saved LinkedIn draft using its exact UUID and expected_version. Omitted mentions, attachments, or first_comment are cleared. A stale version is refused. No provider call or action budget is used.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid" },
+        text: { type: "string", minLength: 1, maxLength: 3000 },
+        mentions: {
+          type: "array", maxItems: 25,
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", minLength: 1, maxLength: 120 },
+              profile_id: { type: "string", minLength: 1, maxLength: 250 },
+            },
+            required: ["name", "profile_id"],
+            additionalProperties: false,
+          },
+        },
+        attachments: {
+          type: "array", maxItems: 20,
+          items: {
+            type: "object",
+            properties: {
+              filename: { type: "string", minLength: 1, maxLength: 180 },
+              content_type: { type: "string", enum: ["image/png", "image/jpeg", "image/webp", "image/gif"] },
+              content_base64: { type: "string", minLength: 1 },
+            },
+            required: ["filename", "content_type", "content_base64"],
+            additionalProperties: false,
+          },
+        },
+        first_comment: { type: "string", minLength: 1, maxLength: 1250 },
+        expected_version: { type: "integer", minimum: 0 },
+      },
+      required: ["id", "text", "expected_version"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_delete_post_draft",
+    path: "/li/delete_post_draft",
+    description: "Permanently delete one exact saved LinkedIn draft. Requires its UUID, current expected_version, and confirm:true. A stale version is refused. This does not delete a LinkedIn-native or scheduled post.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid" },
+        expected_version: { type: "integer", minimum: 0 },
+        confirm: { type: "boolean", const: true },
+      },
+      required: ["id", "expected_version", "confirm"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "li_post_draft_preview",
+    path: "/li/post_draft_preview",
+    description: "Create a short-lived one-use browser link for one exact saved SignalDash LinkedIn draft. The isolated read-only page renders only that draft, its protected stored images, and its draft first comment.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", format: "uuid" },
+      },
+      required: ["id"],
+      additionalProperties: false,
+    },
+  },
   {
     name: "li_scheduled_posts",
     path: "/li/scheduled_posts",
     description: "Read the shared LinkedIn content calendar from SignalDash and the configured Buffer channel. Always inspect completeness and per-source state. Native LinkedIn scheduled posts and drafts are NOT visible because Unipile has no documented read route for them, and SignalDash does not use raw Voyager routes or linkedin.com browser access. An empty items array is never proof that the native LinkedIn calendar is empty.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
   },
+  {
+    name: "li_profile",
+    path: "/li/profile",
+    description: "Read one LinkedIn profile by public id or member id. Returns name, headline, public identifier, provider id, network distance and the profile picture url. Read-only, one provider call, no write. Exists because pictures were otherwise only available for people who had already reacted to or commented on your own posts, which leaves every new name in a shortlist faceless.",
+    inputSchema: {
+      type: "object",
+      properties: { identifier: { type: "string", minLength: 1, maxLength: 200 } },
+      required: ["identifier"],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "sd_share_list",
+    path: "/sd/share_list",
+    description: "Share one selection as a standalone signaldash.dev link, or list and revoke the links that exist. Pass `people` instead of `rows` for a shortlist of humans: each entry renders as a card with a photo when the provider gives one and initials when it does not, plus an optional `score` out of 100 and the `reason` that earned it. A score without a reason is a claim without evidence, so send both or neither, and put the scoring rule in `rubric` where the reader can see it. action:create returns the url ONCE and stores only its hash, so the link cannot be recovered later, only revoked. The page is a fixed snapshot: it never re-reads the source, so a list shared today does not keep disclosing tomorrow's data. action:list shows every live link with its open count; action:revoke kills one by its token.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "list", "revoke"] },
+        title: { type: "string", minLength: 1, maxLength: 200 },
+        note: { type: "string", maxLength: 4000 },
+        columns: { type: "array", minItems: 1, maxItems: 12, items: { type: "string", minLength: 1, maxLength: 80 } },
+        rows: {
+          type: "array", maxItems: 2000,
+          items: { type: "array", items: { type: "string", maxLength: 2000 } },
+        },
+        people: {
+          type: "array", maxItems: 500,
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", minLength: 1, maxLength: 200 },
+              headline: { type: "string", maxLength: 500 },
+              reason: { type: "string", maxLength: 600 },
+              url: { type: "string", maxLength: 500 },
+              image: { type: "string", maxLength: 800 },
+              score: { type: "number", minimum: 0, maximum: 100 },
+              meta: { type: "array", maxItems: 4, items: { type: "string", maxLength: 80 } },
+              org: { type: "string", maxLength: 120 },
+              tags: { type: "array", maxItems: 5, items: { type: "string", maxLength: 28 } },
+              factors: {
+                type: "array", maxItems: 6,
+                items: {
+                  type: "object",
+                  properties: {
+                    label: { type: "string", minLength: 1, maxLength: 60 },
+                    points: { type: "number" },
+                  },
+                  required: ["label"],
+                  additionalProperties: false,
+                },
+              },
+            },
+            required: ["name"],
+            additionalProperties: false,
+          },
+        },
+        rubric: { type: "string", maxLength: 1200 },
+        token: { type: "string", minLength: 1, maxLength: 200 },
+        list_id: { type: "string", minLength: 1, maxLength: 64 },
+      },
+      additionalProperties: false,
+    },
+  },
   {
     name: "li_scheduled_post_preview",
     path: "/li/scheduled_post_preview",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floomhq/signaldash",
-  "version": "0.39.7",
+  "version": "0.39.9",
   "description": "Secure LinkedIn, WhatsApp, and email access for AI agents",
   "type": "module",
   "bin": {

package/skills/signaldash/SKILL.md

@@ -444,13 +444,20 @@ Use the exact tool names and argument keys below. Limits are optional.
 | `li_my_posts` | `limit` default 10, max 50; `member_id` optional | Find the user's latest posts and exact `social_id` values. Omit `member_id` to use the connected user's own ID. Pass `social_id`, not a different numeric `id`, to the engagement tools. |
 | `li_post_reactions` | `post_id` required; use the exact `social_id` from `li_my_posts`; `limit` default 50, max 100; `cursor` optional | Read one bounded page of reactors. Always inspect `completeness.state`, `total`, and `next_cursor`; continue with the cursor while state is `incomplete`. Numeric ids are resolved against the user's own recent posts when possible, including ugcPost-backed multi-image posts. The provider total is reported when available and is never guessed from `li_my_posts`. A reaction does not authorize outreach. |
 | `li_post_comments` | `post_id` required; `comment_id` optional exact parent id; `resolve_reply_state` optional boolean, not combinable with `comment_id`; use the exact `social_id` from `li_my_posts`; `limit` default 50, max 100; `cursor` optional | Read one bounded page of comments, or pass `comment_id` to read replies to that exact parent. Pass `resolve_reply_state: true` before replying to anything: each comment then carries `reply_state.replied_by_me`. Skip every comment whose `replied_by_me` is `true`, and skip every comment whose `replied_by_me` is `null`, which means unknown and never means nobody replied. Only `no_replies` and `answered_by_others` are proven unanswered. Always inspect `completeness.state`, `total`, and `next_cursor`; continue with the cursor while state is `incomplete`. Also inspect `reply_resolution.state`; `partial` or `aborted` means some comments were never resolved. Numeric ids are resolved against the user's own recent posts when possible. The provider total is reported when available and is never guessed from `li_my_posts`. |
-| `li_reply_to_comment` | Manual path: `post_id`, `parent_comment_id`, `trigger_comment_id`, and `text` required; `expected_watermark` optional exact 64-character watermark. Secretary path: `secretary_receipt_id` alone. | Reply once to one exact inbound comment on this sender's own post after `li_post_comments`. SignalDash re-proves post ownership, the unchanged trigger, its author and parent, no own duplicate, sender generation, budget, and provider health immediately before writing. A 2xx is not success until readback finds exactly one matching own reply. |
+| `li_reply_to_comment` | Manual path: `post_id`, `parent_comment_id`, `trigger_comment_id`, and `text` required; `mentions` optional array of `{name, profile_id}`; `expected_watermark` optional exact 64-character watermark. Secretary path: `secretary_receipt_id` alone. | Reply once to one exact inbound comment on this sender's own post after `li_post_comments`. SignalDash re-proves post ownership, the unchanged trigger, its author and parent, no own duplicate, sender generation, budget, and provider health immediately before writing. A 2xx is not success until readback finds exactly one matching own reply. Each mention name must appear exactly once in `text` as a whole word; SignalDash swaps that occurrence for the provider's token, and every tagged person is checked against suppression and protection exactly like the person being replied to. Because the landed comment is compared against `text` character for character, use the person's exact LinkedIn display name or the write is reported unverified. |
 | `li_like_comment` | `post_id`, `parent_comment_id`, and `comment_id` required; `expected_watermark` optional exact 64-character watermark | Like once one exact inbound comment on this sender's own post after `li_post_comments`. SignalDash re-proves post ownership, the unchanged comment, its author and parent, no own like, sender generation, budget, and provider health immediately before writing. A 2xx is not success until bounded readback finds exactly one own like. |
 | `li_delete_message` | `chat_id`, `message_id`, and `confirm:true` required | Remediate one exact own LinkedIn message within 60 minutes of sending. SignalDash proves account, exact chat, own authorship, timestamp eligibility, a separate remediation budget, and the provider's post-delete state. Success requires `deleted:1` or a genuine 404. A present row or failed readback returns `502 deleted_unconfirmed`, locks the sender, and is never retried automatically. This cannot undo delivery, reading, or notifications and never relaxes a send gate. |
 | `li_delete_comment` | `post_id`, `comment_id`, and `confirm:true` required | Currently unavailable: the fixture-tested Unipile v2 wrapper is held at database capability state `untested` until live compatibility is proved against Federico's own removable comment. When enabled it proves own comment identity and readback. Deletion is remediation, not rollback. |
 | `li_draft_post` | `text` required, max 3000; `publish` optional; `scheduled_at` optional offset-qualified ISO date-time; `content_pipeline_id` normally required for scheduling while that user's pipeline is enabled; `content_pipeline_override` optional exact `{reason,confirm?,approval_hash?}`; `mentions` optional array of up to 25 exact `{name,profile_id}` objects; `attachments` optional array of up to 20 exact `{filename,content_type,content_base64}` images, max 5 MiB each and 12 MiB total; `first_comment` optional, max 1250 | Create a server-confirmed draft, publish now, or persist an exact future LinkedIn post and its approved first comment. An enabled pipeline normally runs its fact, exact-text, shared-calendar, frequency, and breathing preflight. For one deliberate exception, preview the exact payload with `{reason}`, show it to the human, then repeat it with `confirm:true` and the returned single-use payload-bound `approval_hash`. The audit record preserves the reason, preview ID, and approval time; every non-pipeline provider safety guard remains active. |
 | `li_set_scheduled_post_first_comment` | `id` required UUID; `first_comment` required, max 1250; `confirm:true` required | Attach one exact approved first comment to a scheduled post. SignalDash publishes it through the same connected account after the post and never republishes the post if the comment fails. |
+| `li_save_post_draft` | `text` required, max 3000; `mentions` optional up to 25; `attachments` optional up to 20 exact images, max 5 MiB each and 12 MiB total; `first_comment` optional, max 1250; `source_key` optional tenant-scoped idempotency key, max 256; `metadata` optional bounded structured source/editorial context | Persist one arbitrary LinkedIn draft without scheduling or publishing. Exact ordered image bytes and ordinary duplicate drafts are retained. An identical `source_key` replay returns the existing draft; changed content under that key is refused. Tenant limits are 1,000 drafts and 100 MiB decoded attachment bytes. No provider call or action budget is used. |
+| `li_post_drafts` | no arguments | List durable SignalDash drafts with attachment metadata, never base64, and return a fresh one-use calendar link. The calendar uses the scheduled-post card design for unscheduled SignalDash and Buffer drafts, with a visible `DRAFT` tag. Stored drafts remain separate from scheduled posts and never appear in `li_scheduled_posts.items`. |
+| `li_update_post_draft` | `id`, complete replacement `text`, and current `expected_version` required; `mentions`, `attachments`, and `first_comment` optional | Atomically replace the complete saved draft. A stale version is refused with the current version and timestamp. Omitting an optional field clears it. No provider call occurs. |
+| `li_delete_post_draft` | `id`, current `expected_version`, and `confirm:true` required | Permanently delete one exact saved SignalDash draft. Unknown, foreign, deleted, and replayed identifiers are indistinguishable. This cannot delete LinkedIn-native or scheduled content. |
+| `li_post_draft_preview` | `id` required UUID | Create a short-lived, single-use `https://signaldash.dev/d/<token>` browser handoff for one exact saved draft. Its page and exact image bytes are protected by a tenant-, draft-, and originating-session-scoped cookie under `/drafts`. |
 | `li_scheduled_posts` | no arguments | Read one shared content-calendar view across SignalDash and the configured Buffer LinkedIn channel. Inspect `completeness` and every `sources.*.state` before treating absence as an empty calendar. Native LinkedIn scheduled posts and drafts are invisible because Unipile has no documented read route for them; SignalDash does not use raw Voyager routes or linkedin.com browser access. An empty `items` array proves only that the visible sources returned no entries. |
+| `li_profile` | `identifier` required, a public id or member id | Read one LinkedIn profile: name, headline, public identifier, provider id, network distance and the profile picture url. Read-only, one provider call, and it returns those six fields rather than the provider's whole record about a person. It exists because pictures were otherwise a by-product of engagement only: reactions and comments carry one, the stored connections carry no picture field, chats carry none, and the invitation preview refuses anyone already connected, so every new name in a shortlist stayed faceless. |
+| `sd_share_list` | `action` create/list/revoke, plus `title`, `columns`, `rows`, optional `note`, or `token` to revoke | Share one selection as a standalone `https://signaldash.dev/l/<token>` page that anyone with the link can open. `create` returns the url ONCE and stores only its SHA-256 hash, so a lost link can be revoked but never recovered. The page is a fixed snapshot and never re-reads the source, so a list shared today does not keep disclosing tomorrow's data. Pass `people` instead of `rows` for a shortlist of humans: each renders as a card with a photo where the provider supplies one and initials where it does not, an optional `score` out of 100, and the `reason` that earned it, with the scoring rule in `rubric` so the reader can check it. For a plain table, every row must have exactly as many cells as there are columns, because a crooked table reads as a claim about the wrong person. `list` shows every live link with its non-secret `list_id` and open count, so a link whose url is lost can still be switched off and a forgotten one stays visible; `revoke` takes either the `token` or that `list_id` and kills it immediately, and a revoked token is indistinguishable from one that never existed. |
 | `li_scheduled_post_preview` | `id` required UUID | Create a short-lived, single-use `https://signaldash.dev/p/<token>` browser handoff for one exact active SignalDash post. The isolated page includes its stored image attachments through account- and post-scoped protected media routes. |
 | `li_edit_scheduled_post` | `id`, `text`, and offset-qualified `scheduled_at` required; full replacement `mentions` (up to 25), image `attachments` (up to 20, max 5 MiB each and 12 MiB total), and `first_comment` optional; confirmation repeats the identical payload with `confirm:true`, `approval_hash`, `expected_version`, and `expected_updated_at` from preview | Atomically replace one scheduled post in place. The UUID, creation time, provider account, and content-pipeline audit fields remain unchanged. A changed or non-scheduled row is refused, approval is single-use and expires, and no provider call occurs. Omitting an optional replacement field clears it. Duplicate identity covers the complete normalized payload, including exact attachment bytes, and only active scheduled or executing rows participate; cancelled history never blocks a replacement. |
 | `li_cancel_scheduled_post` | `id` required UUID; `confirm:true` required | Cancel one exact post while it is still scheduled. It cannot recall an executing or published post. |
@@ -516,6 +523,11 @@ li_delete_message({"chat_id":"chat_li_7f3a","message_id":"msg_li_5c71","confirm"
 li_delete_comment({"post_id":"exact-v2-post-id","comment_id":"exact-own-comment-id","confirm":true})
 li_draft_post({"text":"Most agents need better context, not more autonomy."})
 li_set_scheduled_post_first_comment({"id":"00000000-0000-4000-8000-000000000000","first_comment":"https://github.com/xai-org/x-algorithm","confirm":true})
+li_save_post_draft({"text":"A durable idea with no publication date.","first_comment":"Source link goes here."})
+li_post_drafts({})
+li_update_post_draft({"id":"00000000-0000-4000-8000-000000000000","text":"Complete replacement copy.","expected_version":0})
+li_post_draft_preview({"id":"00000000-0000-4000-8000-000000000000"})
+li_delete_post_draft({"id":"00000000-0000-4000-8000-000000000000","expected_version":1,"confirm":true})
 li_scheduled_posts({})
 li_scheduled_post_preview({"id":"00000000-0000-4000-8000-000000000000"})
 li_edit_scheduled_post({"id":"00000000-0000-4000-8000-000000000000","text":"Exact replacement","scheduled_at":"2026-09-07T08:00:00Z"})
@@ -568,6 +580,16 @@ comment failure never republishes the post. It fails interrupted or ambiguous
 executions closed and never retries them automatically. `email_send` cannot
 start a cold thread and must never be looped over recipients.
 
+When the user wants to keep an arbitrary idea without choosing a publication
+time, use `li_save_post_draft`, not `li_draft_post` with invented scheduling
+arguments. Read it back with `li_post_drafts`; use its returned calendar link
+for the combined read-only scheduled/draft view, or `li_post_draft_preview` for
+one exact draft and its visuals. Updates are complete replacements and require
+the current version, so preserve every optional field the user still wants and
+omit only fields they explicitly want cleared. A saved draft does not grant
+permission to schedule or publish it. Deletion requires explicit approval of
+the exact draft and current version.
+
 ### Exact contact state and suppression
 
 `sd_contact_state` is local and account-scoped. It makes no Unipile, LinkedIn,
@@ -1370,8 +1392,9 @@ own-post engagement actions. An aggregate 75-attempt emergency brake bounds the
 combined lanes. Invitation sends also use the unchanged default 100-attempt
 weekly policy. Separate counters do not alter randomized action spacing, the
 single serialized provider queue, duplicate protection, or provider-warning
-locks. An exact comment reply text already submitted by that sender on the same
-UTC day is refused as `duplicate_comment_text`.
+locks. The same exact comment reply text is allowed up to ten times per sender
+per UTC day; the eleventh is refused as `duplicate_comment_text`. A true resend
+to the SAME comment stays blocked by the idempotency key regardless.
 
 WhatsApp and email share ONE separate daily bucket, and it is independent of
 the LinkedIn one: a WhatsApp message never spends LinkedIn capacity and a

package/skills/signaldash-safe-usage/SKILL.md

@@ -88,8 +88,9 @@ On no, call `sd_secretary_reject` for that exact disposition and send nothing.
 - Let SignalDash serialize LinkedIn writes and apply action-specific jitter. Do
   not parallelize write calls or bypass the guard. Invitation jitter completes
   before the server's final provider preflight and action reservation.
-- Never reuse exact comment reply text during the same UTC day. SignalDash
-  refuses it as `duplicate_comment_text`; changing punctuation only to evade
+- The same exact comment reply text is allowed up to ten times per UTC day,
+  which covers a human replying briefly and repeatedly. The eleventh is
+  refused as `duplicate_comment_text`; changing punctuation only to evade
   that guard is prohibited.
 - Campaign invitations use a sender-local Monday-Friday 09:00-17:00 work
   window and a durable 90-180 second per-sender pacing interval. Timing is