@adrata/adrata-mcp 1.0.47 → 1.0.50

package/access/tiers.js

@@ -254,6 +254,45 @@ export const TOOL_TIERS = {
   update_work_launch: TIERS.ENTERPRISE,
   add_work_item_to_launch: TIERS.ENTERPRISE,
   remove_work_item_from_launch: TIERS.ENTERPRISE,
+  // Threads: goals, indicators, decisions, ideas, discussion (tools/threads/).
+  list_goals: TIERS.ENTERPRISE,
+  get_goal_thread: TIERS.ENTERPRISE,
+  create_goal: TIERS.ENTERPRISE,
+  link_goal: TIERS.ENTERPRISE,
+  list_indicators: TIERS.ENTERPRISE,
+  create_indicator: TIERS.ENTERPRISE,
+  record_indicator_reading: TIERS.ENTERPRISE,
+  list_decisions: TIERS.ENTERPRISE,
+  get_decision: TIERS.ENTERPRISE,
+  record_decision: TIERS.ENTERPRISE,
+  set_decision_status: TIERS.ENTERPRISE,
+  record_decision_outcome: TIERS.ENTERPRISE,
+  take_decision_position: TIERS.ENTERPRISE,
+  link_decision: TIERS.ENTERPRISE,
+  get_decision_graph: TIERS.ENTERPRISE,
+  relate_decisions: TIERS.ENTERPRISE,
+  unrelate_decisions: TIERS.ENTERPRISE,
+  list_ideas: TIERS.ENTERPRISE,
+  get_idea: TIERS.ENTERPRISE,
+  capture_idea: TIERS.ENTERPRISE,
+  set_idea_state: TIERS.ENTERPRISE,
+  link_idea: TIERS.ENTERPRISE,
+  list_discussion: TIERS.ENTERPRISE,
+  list_thread_changes: TIERS.ENTERPRISE,
+  post_discussion: TIERS.ENTERPRISE,
+  resolve_discussion: TIERS.ENTERPRISE,
+  // Propositions, the graph read and document filing (tools/threads/work-proposition-tools.js).
+  list_propositions: TIERS.ENTERPRISE,
+  get_proposition: TIERS.ENTERPRISE,
+  get_proposition_calibration: TIERS.ENTERPRISE,
+  state_proposition: TIERS.ENTERPRISE,
+  record_proposition_reading: TIERS.ENTERPRISE,
+  set_proposition_status: TIERS.ENTERPRISE,
+  link_proposition: TIERS.ENTERPRISE,
+  unlink_proposition: TIERS.ENTERPRISE,
+  get_thread_graph: TIERS.ENTERPRISE,
+  file_document: TIERS.ENTERPRISE,
+  unfile_document: TIERS.ENTERPRISE,
   set_work_board_column_wip_limit: TIERS.ENTERPRISE,
   attach_work_item_qa_evidence: TIERS.ENTERPRISE,
   verify_work_item_qa_evidence_playback: TIERS.ENTERPRISE,

package/api-bridge.js

@@ -224,6 +224,20 @@ const ALLOWED_PREFIXES = [
   '/api/v1/work-items',
   // A launch is a lens over the boards; its writes are board writes.
   '/api/v1/work-launches',
+  // The threads family: goals, indicators, decisions, ideas, the discussion
+  // under them and their field-change log. None is a board citizen; their
+  // writes are board-family writes (read:tasks / write:tasks), and every one
+  // is listed separately because matchesPathPrefix is segment-boundary matched.
+  '/api/v1/work-decisions',
+  '/api/v1/work-discussions',
+  '/api/v1/work-goals',
+  '/api/v1/work-ideas',
+  '/api/v1/work-indicators',
+  '/api/v1/work-propositions',
+  '/api/v1/work-thread-changes',
+  // The one graph read, any root (`/work-threads/graph`); the family name
+  // is `work-threads`, listed separately for the same segment-boundary reason.
+  '/api/v1/work-threads',
   // The containers above the cards (initiative / epic / feature) and the
   // "add this to the roadmap" verb. Creating an epic proposal is a governed
   // write like any other; the strategic commitment itself still moves through
@@ -357,6 +371,17 @@ const PATH_WRITE_SCOPES = [
   ['/api/v1/work-items', 'write:tasks'],
   ['/api/v1/work-board-rollups', 'write:tasks'],
   ['/api/v1/work-launches', 'write:tasks'],
+  // The threads family maps onto the same scope family as the boards it
+  // hangs beside; without these rows a thread write previews as
+  // `requiredScope: "unknown (no mapping for this path)"`.
+  ['/api/v1/work-goals', 'write:tasks'],
+  ['/api/v1/work-indicators', 'write:tasks'],
+  ['/api/v1/work-decisions', 'write:tasks'],
+  ['/api/v1/work-ideas', 'write:tasks'],
+  ['/api/v1/work-discussions', 'write:tasks'],
+  ['/api/v1/work-thread-changes', 'write:tasks'],
+  ['/api/v1/work-propositions', 'write:tasks'],
+  ['/api/v1/work-threads', 'write:tasks'],
 ];
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adrata/adrata-mcp",
-  "version": "1.0.47",
+  "version": "1.0.50",
   "description": "Adrata MCP Server \u2014 connect Claude Code, Codex, Gemini, Cursor, and other AI tools to your CRM. About 275 tools registered at startup for companies, people, deals, actions, buyer groups, warm intros, webhooks and intelligence, plus 65 more behind eight named toolsets you load with enable_toolset.",
   "type": "module",
   "main": "server.js",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "start": "node server.js",
-    "test": "node --test analytics.test.js server.test.js api-bridge.test.js http/edge-block.test.js http/rate-limit.test.js audit-flush.test.js buyer-group-writes.test.js note-writes.test.js mcp-spec.test.js packaging.test.js product-profile.test.js security.test.js security.cap-contract.test.js tool-annotations.test.js toolsets.test.js toolsets/communications.test.js toolsets/prospecting.test.js access/auth.test.js access/oauth-callback.test.js access/oauth-session.test.js access/oauth-capabilities.test.js access/oauth-scope-grantability.test.js scripts/local-dev-server.test.js tools/competitive-coverage.test.js tools/describe-count.test.js tools/email-tools.test.js tools/scheduling.test.js tools/work-board-tools.test.js tools/launches/work-launch-tools.test.js tools/work-hub/audit.test.js tools/work-hub/field-changes.test.js tools/work-hub/criteria-quality.test.js tools/roadmap-tools.test.js tools/provisioning/onboarding-tools.test.js tools/source-control/connection-tools.test.js governance/money.test.js http/rate-limit-policy.test.js"
+    "test": "node --test analytics.test.js server.test.js api-bridge.test.js http/edge-block.test.js http/rate-limit.test.js audit-flush.test.js buyer-group-writes.test.js note-writes.test.js mcp-spec.test.js packaging.test.js product-profile.test.js security.test.js security.cap-contract.test.js tool-annotations.test.js toolsets.test.js toolsets/communications.test.js toolsets/prospecting.test.js access/auth.test.js access/oauth-callback.test.js access/oauth-session.test.js access/oauth-capabilities.test.js access/oauth-scope-grantability.test.js scripts/local-dev-server.test.js tools/competitive-coverage.test.js tools/describe-count.test.js tools/email-tools.test.js tools/scheduling.test.js tools/work-board-tools.test.js tools/launches/work-launch-tools.test.js tools/threads/work-thread-tools.test.js tools/work-hub/audit.test.js tools/work-hub/field-changes.test.js tools/work-hub/criteria-quality.test.js tools/roadmap-tools.test.js tools/provisioning/onboarding-tools.test.js tools/source-control/connection-tools.test.js governance/money.test.js http/rate-limit-policy.test.js"
   },
   "keywords": [
     "mcp",

package/server.js

@@ -54,6 +54,7 @@ import { registerEnterpriseTools } from './tools/enterprise-tools.js';
 import { registerEmailTools } from './tools/email-tools.js';
 import { registerWorkBoardTools } from './tools/work-board-tools.js';
 import { registerWorkLaunchTools } from './tools/launches/work-launch-tools.js';
+import { registerWorkThreadTools } from './tools/threads/work-thread-tools.js';
 import { registerSourceControlTools } from './tools/source-control/connection-tools.js';
 import { registerRoadmapTools } from './tools/roadmap-tools.js';
 import { registerProvisioningTools } from './tools/provisioning/onboarding-tools.js';
@@ -1828,14 +1829,30 @@ server.tool('get_company_firmographics', 'Get employee count and revenue metadat
   { companyId: z.string() },
   async (a) => ok(await api('GET', `/api/v1/companies/${a.companyId}/firmographics`)));
 
-server.tool('enrich_person', `Trigger enrichment for a person — professional info, social profiles. SPENDS VENDOR CREDITS (a Coresignal collect is 20 credits per person).${governedWriteNote('write:people')}`,
-  { personId: z.string(), ...governedWriteArgs },
-  async ({ personId, ...g }) => runGovernedWrite(
+// `enrichPhone` and `forceRefresh` reach the route ONLY through the request
+// body, and this tool used to send none at all — no `body` key, so the POST went
+// out empty and the route's `enrich_phone` fell to its `unwrap_or(false)`
+// default on every call. The flag was therefore unreachable from MCP: an agent
+// could pass it, the schema would accept it, and no vendor was ever asked for a
+// phone. That is the "capability that nothing can reach" shape, and it is the
+// reason phone was never requested on any of the async jobs in production.
+server.tool('enrich_person', `Trigger enrichment for a person — email, phone, professional info, social profiles. SPENDS VENDOR CREDITS. Phone is a separate paid field (a BetterContact mobile is 10 credits against 1 for an email), so pass enrichPhone: true whenever the ask is for a mobile, cell, direct line or "contact details" — without it no vendor is asked for a number and the run still reports success.${governedWriteNote('write:people')}`,
+  {
+    personId: z.string(),
+    enrichPhone: z.boolean().optional().describe('Also look up a mobile/direct phone. Paid field, explicit opt-in, defaults false.'),
+    forceRefresh: z.boolean().optional().describe('Run even when fields are already populated; only for an explicitly stale or wrong record.'),
+    ...governedWriteArgs,
+  },
+  async ({ personId, enrichPhone, forceRefresh, ...g }) => runGovernedWrite(
     g,
     {
       method: 'POST',
       path: `/api/v1/people/${personId}/enrich`,
-      preview: { entity: 'person', entityId: personId, operation: 'enrich', spendsVendorCredits: true },
+      body: body({ enrichPhone, forceRefresh }),
+      preview: {
+        entity: 'person', entityId: personId, operation: 'enrich',
+        spendsVendorCredits: true, enrichPhone: enrichPhone === true,
+      },
     },
   ));
 
@@ -2421,6 +2438,20 @@ registerWorkLaunchTools(server, {
   getGrantedScope: () => loadTokens()?.scope,
 });
 
+// ===== THREAD TOOLS =====
+// Goals, propositions, indicators, decisions, ideas and the discussion under
+// them — the threads family — plus the one graph read and Galaxy document
+// filing. Nothing is a board citizen, progress derived on read. Same governed
+// contract; see tools/threads/work-thread-tools.js.
+registerWorkThreadTools(server, {
+  z,
+  api,
+  ok,
+  validateApiBridgeRequest,
+  buildMutationHeaders,
+  getGrantedScope: () => loadTokens()?.scope,
+});
+
 registerSourceControlTools(server, {
   z,
   api,

package/server.json

@@ -3,7 +3,7 @@
   "name": "com.adrata/adrata-mcp",
   "description": "Adrata revenue-intelligence MCP server: companies, people, opportunities, actions, buyer groups, enrichment, email, and workspace operations for AI agents.",
   "status": "active",
-  "version": "1.0.47",
+  "version": "1.0.50",
   "websiteUrl": "https://adrata.com/developers",
   "repository": {
     "url": "https://github.com/adrata/adrata",
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@adrata/adrata-mcp",
-      "version": "1.0.47",
+      "version": "1.0.50",
       "transport": {
         "type": "stdio"
       },

package/skills/capture-to-idea/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: capture-to-idea
+description: Turn something you just read or heard — a customer call, a competitor's launch, a keynote, an audit finding, a note from the owner — into the right Starfield thread record with its source attached. Use when someone says "capture this", "we should do X", "add this to the ideas", or when an audit turns up a gap worth remembering rather than a bug worth fixing.
+---
+
+# Capture to idea
+
+The gap between "somebody said something smart" and "we did it" is the
+record. A Slack line evaporates; a card is the wrong size for it; an epic is
+too big a commitment for a hunch. The threads family exists for exactly this
+middle: an **idea** with the vector it arrived on and the source it came from,
+so six weeks later the next person can go back to the transcript instead of
+to your memory of it.
+
+This skill is about spending three minutes now so the capture is findable,
+attributable and honest.
+
+## First: which noun is it?
+
+Four nouns share the thread tools, and putting a thing in the wrong one is
+the most common mistake. Decide before you write:
+
+| You are holding… | It is a… | Tool |
+|---|---|---|
+| A thing we could build or do, whose value is still an argument | **idea** | `capture_idea` |
+| An outcome we are committing to, or a bet on how to reach one | **goal** / **strategy** | `create_goal` |
+| A ruling — a choice among alternatives that others must now live with | **decision** | `record_decision` |
+| A number that says whether a goal is on track, or a new reading of one | **indicator** / reading | `create_indicator`, `record_indicator_reading` |
+| A claim about the world we are acting on, that evidence could show false | **proposition** | `state_proposition` |
+| A bug, an outage, a thing that is broken right now | a **card** | the `incident-to-card` skill, not this one |
+
+Two tells. If the sentence has "we should…" in it, it is an idea until someone
+with the authority to commit says so. If the sentence has "we will no longer…"
+or "from now on…", it is a decision, and it needs the alternatives it beat and
+who decided. A number with no goal behind it is not an indicator yet; capture
+the idea that there should be a goal.
+
+## Read the source before you write anything
+
+Read the whole thing — the transcript, the doc, the thread, the audit — not the
+summary of it. Then extract, without inventing:
+
+1. **The outcome** — what would be true if this idea were realized, as a
+   statement. Not the feature. "Sellers see which buyer-group member is the
+   real decision-maker before the first call", not "add a decision-maker badge".
+2. **Who it serves** — the audience. `seller | manager | leader` are the people
+   Adrata serves; `builder` is us building Adrata, Starfield and Portals;
+   `company` is the whole business. Pick the one the source actually names.
+3. **Where it came from** — the vector, chosen honestly (below).
+4. **The source itself** — the specific, re-findable thing: the URL, the
+   `company/...` path, the customer's name and the call date, the transcript
+   title, the audit's name. "Ross said" is not a source; the ideas notepad path
+   and the heading is.
+5. **What it links to** — an existing goal it serves, an epic or card that
+   already realizes part of it, a decision that constrains it, another idea it
+   is a variant of.
+
+If you cannot state the outcome from the source, write what the source said
+and mark the outcome as unstated. A confident outcome the source never
+expressed is your idea wearing their name.
+
+## Pick the vector honestly
+
+`vector` is where the idea arrived from, and it is required because the
+distribution of vectors is itself a signal — a roadmap fed only by `owner` and
+`internal_audit` is a roadmap nobody outside asked for.
+
+- `owner` — the owner said it (the ideas notepad, a direct message, a ruling in
+  passing). Only when he actually did.
+- `customer` — a paying or prospective customer said it, named. Not "customers
+  probably want".
+- `buyer_demand` — a pattern across buyers: several deals, a lost-deal reason,
+  an RFP requirement. Name the deals.
+- `competitor` — a competitor shipped or announced it. Name the release.
+- `keynote` — it came from a talk, a paper, a conference. Name the talk.
+- `internal_audit` — an audit, a review or a measurement of our own product
+  turned it up. Name the audit.
+- `technology` — a new capability made it possible (a model, an API, a
+  platform change). Name it.
+- `regulation` — a law, a compliance regime, a platform policy requires it.
+
+The flattering vector is usually `customer`. If one customer mentioned it once
+in passing, it is `customer` with that customer named and a body that says
+"mentioned once". Do not upgrade it to `buyer_demand`.
+
+## Check before you create
+
+1. `list_ideas` filtered by the audience, and skim titles. A near-duplicate
+   idea is a list nobody reads; if one exists, `post_discussion` on it with the
+   new source and `link_idea` if the new source connects it to something.
+2. `list_goals` for the goal it serves. Most ideas serve one; say which.
+3. `list_work_scopes` when the idea sounds like an epic that may already exist.
+   If an epic already realizes it, the idea is still worth capturing (the
+   source and the vector are new information), linked to that scope.
+
+## Writing it
+
+**Title**: the outcome, at most 160 characters. Someone scanning `/ideas`
+must be able to tell what would be different without opening it.
+
+**Body**: what it is, who it is for, why now, what it would take — under plain
+headings. Quote the source where you can, verbatim, in a block. Say what you
+do not know. Do not write acceptance criteria; an idea is not a card.
+
+## Filing it
+
+1. `capture_idea` with `title`, `body`, `vector`, `source`, `audience`. The
+   idea lands in state `captured`. Do not set a state; exploring is a later
+   act with its own reason.
+2. `link_idea` with `scopeId`, `workItemId` or `relatedIdeaId` for each
+   connection you found, one call each, with a reason in a sentence.
+3. `link_goal` with the `goalId` and `ideaId` if it serves a goal.
+4. If a decision constrains it, `link_decision` from that decision to the idea.
+
+If you decided it was a **goal**: `create_goal` (level `goal`, or `strategy`
+with `parentGoalId`; a strategy is a bet, so give its hypothesis, falsifier and
+confidence). If it was a **decision**: `record_decision` with the alternatives
+and a `door`; it lands `proposed`, and people take positions on it. If it was
+an **indicator**: `create_indicator` with the definition that stops two people
+reading two numbers, then `record_indicator_reading` for the number you have.
+
+## Propositions: when the source is a claim, not a thing
+
+Some sources are not a thing to build. They are a claim about the world that
+our plans rest on: "enterprise buyers will pay for provable control", "sellers
+will not type into a CRM", "the three rocks are the fastest route to $1M ARR".
+Filing that as an idea loses it; the claim is what a strategy's hypothesis and
+a decision's reversal condition were both privately pointing at. File a
+**proposition** instead:
+
+1. `list_propositions` first. The same claim stated twice is two confidence
+   histories nobody can reconcile; if it exists, `record_proposition_reading`
+   with the new evidence and its source.
+2. `state_proposition` with the `statement` as one sentence, the `rationale`,
+   a `confidence` (your honest probability, 0-1; it becomes the first reading
+   and is scored later), the `falsifier` — the observation that would show it
+   false, required, because a claim with no falsifier is a slogan — and the
+   `audience`.
+3. `link_proposition` to each goal, decision, idea or indicator that rests on
+   it, with a reason. That is the `assumes` edge; when the claim is falsified,
+   everything linked lights up.
+4. If the source is a document — the audit, the transcript, the deck — file it
+   with `file_document` (family `proposition`, role `evidence` or `source`).
+
+Never edit a proposition's confidence: every change is a reading with its
+evidence. A source that argues *against* a claim we hold is a reading with a
+lower confidence, not a new proposition.
+
+## Promotion is a separate act
+
+Do not create an epic to capture an idea. When an idea has earned an epic,
+that is `add_to_roadmap` (it creates the proposed scope and hands you the git
+half to write), then `link_idea` with the new `scopeId`, then `set_idea_state`
+to `committed` with the reason. Three verbs, because they are three decisions
+someone can disagree with separately.
+
+## Writes
+
+Every thread write is governed: it previews by default. Show the human the
+record you are about to file — title, body, vector, source, audience, and the
+links — and file it only after they say yes, with `dryRun: false`,
+`approved: true`, a `reason`, and an `idempotencyKey`. Reuse the same key on
+retry so a flaky connection does not capture the same idea twice.
+
+## After filing
+
+Report the idea id, its vector and source, and what it was linked to. If
+reading the source surfaced a second thing — a bug, a decision nobody
+recorded, a number nobody tracks — say so as a separate line, clearly marked
+as your observation rather than as something the source said.

package/tool-annotations.js

@@ -129,6 +129,48 @@ const DOMAIN_OVERRIDES = {
   update_work_launch: 'board',
   add_work_item_to_launch: 'board',
   remove_work_item_from_launch: 'board',
+  // Threads: goals, indicators, decisions, ideas, discussion (tools/threads/).
+  // Board pack because they hang beside the boards and share its scope family;
+  // without an override `list_goals` would fall to the general catch-all.
+  list_goals: 'board',
+  get_goal_thread: 'board',
+  create_goal: 'board',
+  link_goal: 'board',
+  list_indicators: 'board',
+  create_indicator: 'board',
+  record_indicator_reading: 'board',
+  list_decisions: 'board',
+  get_decision: 'board',
+  record_decision: 'board',
+  set_decision_status: 'board',
+  record_decision_outcome: 'board',
+  take_decision_position: 'board',
+  link_decision: 'board',
+  get_decision_graph: 'board',
+  relate_decisions: 'board',
+  unrelate_decisions: 'board',
+  list_ideas: 'board',
+  get_idea: 'board',
+  capture_idea: 'board',
+  set_idea_state: 'board',
+  link_idea: 'board',
+  list_discussion: 'board',
+  list_thread_changes: 'board',
+  post_discussion: 'board',
+  resolve_discussion: 'board',
+  // Propositions (the fifth noun), the one graph read and Galaxy document
+  // filing live in the same family (tools/threads/work-proposition-tools.js).
+  list_propositions: 'board',
+  get_proposition: 'board',
+  get_proposition_calibration: 'board',
+  state_proposition: 'board',
+  record_proposition_reading: 'board',
+  set_proposition_status: 'board',
+  link_proposition: 'board',
+  unlink_proposition: 'board',
+  get_thread_graph: 'board',
+  file_document: 'board',
+  unfile_document: 'board',
   list_forms: 'forms',
   get_form: 'forms',
   create_form: 'forms',
@@ -234,6 +276,14 @@ const DESTRUCTIVE = new Set([
   // destructiveHint — a host would not have confirmation-gated a delete.
   'manage_company', 'manage_person', 'manage_opportunity', 'manage_activity',
   'manage_buyer_group',
+  // Decision graph: unrelate_decisions DELETEs an edge and the reason recorded
+  // on it. The name has no `delete_` prefix (it is the graph's own verb), so
+  // it is listed here to be confirmation-gated; it stays idempotent below.
+  'unrelate_decisions',
+  // Same shape for the proposition's assumes edge and a Galaxy document
+  // filing: each DELETE drops the row and the reason recorded on it, and
+  // neither name carries a delete_ prefix. Both stay idempotent below.
+  'unlink_proposition', 'unfile_document',
 ]);
 
 /** True when a tool is destructive (irreversible delete, spend, or send). */
@@ -265,6 +315,31 @@ const IDEMPOTENT_WRITES = new Set([
   // A repeat block is the same edge (the pair is unique), and a repeat
   // unblock deletes a row that is already gone. Neither compounds.
   'block_work_item', 'unblock_work_item',
+  // Threads. link_goal / link_decision / link_idea are ON CONFLICT upserts on
+  // a join table keyed by the pair: replaying the same link rewrites the same
+  // row's reason and adds no edge. take_decision_position is an upsert per
+  // (decision, user): the second call replaces the first position, so a retry
+  // lands on the same state. resolve_discussion sets or clears resolved_at on
+  // one root post; a repeat sets what is already set. Deliberately NOT here:
+  // record_indicator_reading, post_discussion, create_goal, create_indicator,
+  // record_decision and capture_idea each APPEND a row per call, and
+  // set_idea_state / set_decision_status each append a history row — see
+  // NON_IDEMPOTENT_WRITES.
+  'link_goal', 'link_decision', 'link_idea', 'take_decision_position', 'resolve_discussion',
+  // Decision graph edges are keyed by (decision, related decision, relation):
+  // a repeat relate rewrites the same edge's reason, a repeat unrelate deletes
+  // an edge already gone. Neither compounds. unrelate is its own verb rather
+  // than a flag on relate so the removal is visible in the tool NAME — and it
+  // is in DESTRUCTIVE above (it drops the edge and its reason), so it is
+  // destructive AND idempotent, like every delete/revoke.
+  'relate_decisions', 'unrelate_decisions',
+  // Propositions: link_proposition is an ON CONFLICT upsert keyed by
+  // (proposition, target type, target id), and file_document by (target,
+  // document): a repeat rewrites the same row's reason (and role). Their
+  // removals delete a row already gone on a repeat. Deliberately NOT here:
+  // state_proposition and record_proposition_reading each APPEND a row, and
+  // set_proposition_status appends a history row — see NON_IDEMPOTENT_WRITES.
+  'link_proposition', 'unlink_proposition', 'file_document', 'unfile_document',
   'add_work_item_acceptance_criterion',
   // (delete_work_item needs no entry here either: DESTRUCTIVE_PATTERN matches
   // the `delete_` prefix, so a host confirmation-gates it on its NAME. That is
@@ -308,6 +383,16 @@ const NON_IDEMPOTENT_WRITES = new Set([
   'enable_toolset', 'track_conversion', 'log_interaction', 'test_webhook',
   'replay_webhook_delivery', 'upgrade_account',
   'release_work_item_qa_pass',
+  // Threads: every one of these appends a row per call — a reading, a post, a
+  // goal, an indicator, a decision, an idea, a state-history row, or a written-
+  // once outcome — so a retry under a FRESH idempotency key compounds.
+  'create_goal', 'create_indicator', 'record_indicator_reading',
+  'record_decision', 'set_decision_status', 'record_decision_outcome',
+  'capture_idea', 'set_idea_state', 'post_discussion',
+  // Propositions: a stated claim, a reading (the confidence history IS the
+  // calibration record, so a duplicate reading is a real distortion), and a
+  // status transition with its history row.
+  'state_proposition', 'record_proposition_reading', 'set_proposition_status',
 ]);
 
 // Tools that reach beyond the workspace (external enrichment, web, providers).