@adrata/adrata-mcp 1.0.19 → 1.0.40

package/tools/work-hub/criteria-quality.js

@@ -52,6 +52,50 @@
  * word. The cost of that false positive is an author learning to ignore the
  * notes, which is worse than the check not existing. When in doubt these rules
  * stay silent.
+ *
+ * # The 2026-09-08 correction: it was firing on the good ones
+ *
+ * Measured across a complete census — 648 criteria on 220 cards — the
+ * placeholder rule found **zero of the 12 genuinely unexecutable criteria** and
+ * produced **seven false positives**. That is worse than no check at all,
+ * because it is believed: it steers a grader toward well-written criteria and
+ * away from the ones that cannot fail. What it fired on, verbatim:
+ *
+ *   - `WIP = throughput × cycle time` and the WIP-limit card itself, on a board
+ *     whose own feature is WIP limits.
+ *   - `The <video> element autoplays muted …`, because `<[^>]{0,40}>` cannot
+ *     tell a referent from an unfilled slot.
+ *   - `The draft email body contains no placeholder tokens` — a criterion that
+ *     is correct *because* it says that word.
+ *   - the classifier's own fixture card, which must name TODO and N/A as data.
+ *
+ * Three repairs follow, and each is a NARROWING that had to be tested in both
+ * directions — a genuine `TODO` must still fire, or the fix is just a silence:
+ *
+ *   1. **`wip` is gone.** It is a live domain term here and nothing in this
+ *      corpus separates "WIP limit" from "WIP" as an unfinished marker. #3871
+ *      tried a `(?![\s-]+limits?)` lookahead; it still fired on a sentence
+ *      carrying BOTH senses. Removing a token that cannot discriminate is a
+ *      strengthening — every remaining token means one thing.
+ *   2. **Angle brackets classify the inner text** (`isUnfilledSlot`) instead of
+ *      matching any `<…>`. `<video>` and `<Button>` are referents; `<name>` and
+ *      `<fill this in>` are slots.
+ *   3. **A negated or quoted mention does not fire.** "contains no placeholder",
+ *      "must not say TODO", "names TODO as data" — the criterion is naming the
+ *      thing it forbids or the literal it expects. Same shape as the flag
+ *      disclaimer window in `scripts/fleet/stale-flag-detector.mjs`.
+ *
+ * And the other half, which is the more valuable one: the check missed EVERY
+ * real defect, so `ADJECTIVAL_THEN` and `CATEGORICAL_WHERE` were added for the
+ * two commonest shapes in that census — a `then` that is pure adjectives
+ * ("warm, sharp, candid", "near black", "usable overflow") and a `where` that
+ * names a category rather than a place ("Representative seller conversations",
+ * "code/api — wherever it is implemented"). Both stay advisory.
+ *
+ * Two shapes from that census are deliberately NOT attempted here, because a
+ * regex would guess: several fault states folded into one criterion (one had
+ * seven), and a `then` naming no value at all in a long sentence. Both need to
+ * read the sentence, not match it.
  */
 
 /** Lowercase, collapse whitespace, drop trailing punctuation. */
@@ -109,9 +153,179 @@ const UNLOCATED_WHERE = [
   /^(?:it|this|there|here|everywhere|anywhere|all surfaces|any surface|none|various)$/,
 ];
 
-/** Text nobody has written yet, left in a field that is required to be written. */
-const PLACEHOLDER =
-  /(?:^|[^a-z0-9])(?:tbd|tba|todo|fixme|wip|xxx|placeholder|n\/a)(?:[^a-z0-9]|$)|\?{3,}|<[^>]{0,40}>/i;
+/**
+ * A `where` that names a CATEGORY of place rather than a place.
+ *
+ * Distinct from `UNLOCATED_WHERE`, which catches the whole-product noun. This
+ * catches the field that reads like a sampling frame — "Representative seller
+ * conversations" — or that defers the location to the reader — "code/api —
+ * wherever it is implemented". Both are answers to "what kind of place"; the
+ * field asks "which one", and the next reviewer cannot stand in a category.
+ *
+ * `all` / `each` / `every` are deliberately absent from the quantifier list: "all
+ * three boards in the workspace" is an exhaustive scope, which is a real answer.
+ */
+const CATEGORICAL_WHERE = [
+  /^(?:a |an |the )?(?:representative|typical|assorted|various|relevant|appropriate|applicable|indicative|sample|example|some|several|a few|any)\b/,
+  /\b(?:wherever|as applicable|if applicable|as appropriate|as needed|where (?:it|they|that) (?:is|are) (?:implemented|used|defined|rendered|handled))\b/,
+];
+
+/**
+ * A `then` made only of adjectives — the commonest real defect in the census
+ * and one the rules above could not see, because it is not a fixed phrase.
+ *
+ * Three conditions, all required, and the conjunction is what keeps it quiet:
+ * the clause is at most three words, it carries no falsifiable anchor (see
+ * `hasFalsifiableAnchor`), and at least one of its words is a subjective quality
+ * word. "The badge is green" is four words and stays silent; "near black" is two
+ * and does not.
+ */
+const VAGUE_QUALITY = new Set([
+  // quality adjectives a reviewer cannot disagree with
+  'warm', 'sharp', 'candid', 'crisp', 'clean', 'clear', 'smooth', 'snappy',
+  'polished', 'tidy', 'neat', 'readable', 'legible', 'usable', 'sensible',
+  'reasonable', 'appropriate', 'nice', 'pleasant', 'elegant', 'modern',
+  'professional', 'intuitive', 'seamless', 'robust', 'solid', 'consistent',
+  'coherent', 'obvious', 'natural', 'comfortable', 'balanced', 'subtle',
+  'punchy', 'tight', 'generous', 'minimal', 'simple', 'friendly',
+  'approachable', 'compelling', 'engaging', 'delightful', 'beautiful',
+  'responsive', 'performant', 'stable', 'reliable', 'good', 'great', 'fine',
+  'better', 'improved', 'acceptable', 'adequate', 'sufficient', 'correct',
+  'proper', 'right', 'accurate',
+  // hedges — a value that is "near" something is not a value
+  'near', 'roughly', 'approximately', 'about', 'around', 'slightly', 'somewhat',
+  'fairly', 'quite', 'very', 'pretty', 'mostly', 'generally', 'largely',
+  // bare colour and size, with no value beside them
+  'black', 'white', 'grey', 'gray', 'dark', 'light', 'big', 'small', 'large',
+  'tall', 'short', 'wide', 'narrow', 'thin', 'thick', 'fast', 'slow', 'quick',
+]);
+
+/**
+ * Something in the clause a reviewer could look for and fail to find: a number,
+ * a quoted or code-fenced literal, a path or identifier, or a capitalised label
+ * anywhere but the sentence's first word.
+ *
+ * Read on the RAW text, not the normalised one, because normalising lowercases
+ * — and case is half of what makes a label a label.
+ */
+function hasFalsifiableAnchor(raw) {
+  const text = String(raw ?? '').trim();
+  if (!text) return false;
+  if (/[0-9]/.test(text)) return true;
+  if (/["'`“”‘’]/.test(text)) return true;
+  if (/[/_=<>{}()[\]#%]/.test(text)) return true;
+  const words = text.split(/\s+/);
+  return words.slice(1).some((word) => /^[A-Z]/.test(word) || /[a-z][A-Z]/.test(word));
+}
+
+/**
+ * Placeholder markers. `wip` is deliberately absent — see the header. `tbc` is
+ * new and unambiguous, and it is what made `<copy tbc>` detectable once the
+ * blanket angle-bracket rule went.
+ */
+const PLACEHOLDER_MARKER = /(?:^|[^a-z0-9])(tbd|tba|tbc|todo|fixme|xxx|placeholder|n\/a)(?:[^a-z0-9]|$)/gi;
+
+/** Three or more question marks is nobody's referent. */
+const UNANSWERED = /\?{3,}/;
+
+/**
+ * A marker the author is NAMING rather than leaving behind.
+ *
+ * Two families, one window. Negation — "contains no placeholder", "must not say
+ * TODO" — and quotation verbs — "names TODO as data", "the literal TODO". The
+ * 24-character window is the same bounded-lookback shape as `disclaimerNearRef`
+ * in `scripts/fleet/stale-flag-detector.mjs`: near enough to be about this
+ * marker, short enough that a negation two sentences back cannot excuse it.
+ *
+ * `reads` / `shows` / `displays` are deliberately NOT here. "The banner reads
+ * TBD" is genuinely ambiguous between an expected literal and an unfinished
+ * clause, and this file's standing rule is that ambiguity stays loud in the
+ * direction of the marker.
+ *
+ * The window stops at `. , ; :` as well as at 24 characters. That clause
+ * boundary is what keeps "the summary names every owner, TBD which column"
+ * firing: the naming verb is inside 24 characters but it is about a different
+ * object, and the comma says so.
+ */
+const EXCUSED_BEFORE =
+  /\b(?:no|not|never|without|absent|excluding|neither|nor|free of|rather than|other than|names?|named|naming|quotes?|quoted|literal(?:ly)?|marker|markers|token|tokens|string|strings|word|words|spelled|spelling|placeholder)\b[^.,;:]{0,24}$/i;
+
+/** A marker wrapped in quotes or backticks is a literal under discussion. */
+function isQuotedAt(text, start, end) {
+  const before = text.slice(Math.max(0, start - 1), start);
+  const after = text.slice(end, end + 1);
+  return /["'`“‘]/.test(before) && /["'`”’]/.test(after);
+}
+
+/**
+ * HTML element names, so `<video>` reads as the referent it is. Not exhaustive
+ * and does not need to be: everything it misses falls through to the
+ * capitalised-component and multi-word tests below.
+ */
+const HTML_ELEMENTS = new Set(
+  ('a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption ' +
+    'cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset ' +
+    'figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ' +
+    'ins kbd label legend li link main map mark menu meta meter nav noscript object ol optgroup ' +
+    'option output p param picture pre progress q rp rt ruby s samp script section select slot small ' +
+    'source span strong style sub summary sup table tbody td template textarea tfoot th thead time ' +
+    'title tr track u ul var video wbr svg path circle rect g defs use'
+  ).split(' ')
+);
+
+/**
+ * Does `<…>` hold an unfilled slot, or a referent the author meant to name?
+ *
+ * The blanket `<[^>]{0,40}>` this replaces could not tell them apart, so it
+ * flagged `<video>`. Order matters: attributes and closing tags settle it first,
+ * then a multi-word inside is prose and therefore a slot, then a capitalised
+ * single token is a JSX component, then a known element name.
+ *
+ * What is left — a lowercase single token that is not an HTML element — is read
+ * as a slot: `<name>`, `<slug>`, `<workspace>`. The cost of that choice is a
+ * custom element like `<my-widget>` written bare in a criterion, which is rarer
+ * in this corpus than the slot it catches.
+ */
+function isUnfilledSlot(inner) {
+  const text = inner.trim();
+  if (!text || text.length > 40) return false;
+  if (text !== inner) return false; // "a < b and c > d" — padded, so it is a comparison
+  if (text.includes('=')) return false; // <input type="text">
+  if (/^[/!?]/.test(text)) return false; // </div>, <!-- -->, <?xml
+  const words = text.split(/\s+/);
+  if (words.length > 1) return words.length <= 5 && words.every((word) => /^[\w'’-]+$/.test(word));
+  const token = text.replace(/\/$/, ''); // <br/>
+  if (/^[A-Z]/.test(token)) return false; // <Button> — a JSX component
+  return !HTML_ELEMENTS.has(token.toLowerCase());
+}
+
+/**
+ * Every placeholder marker in one field that is not excused, plus any unfilled
+ * angle-bracket slot. Returns the matched text, or `null` when the field is
+ * clean — the caller only needs to know whether to speak.
+ */
+export function findPlaceholder(raw) {
+  const text = String(raw ?? '');
+  if (!text.trim()) return null;
+
+  PLACEHOLDER_MARKER.lastIndex = 0;
+  for (const hit of text.matchAll(PLACEHOLDER_MARKER)) {
+    const marker = hit[1];
+    const start = hit.index + hit[0].indexOf(marker);
+    const end = start + marker.length;
+    if (isQuotedAt(text, start, end)) continue;
+    if (EXCUSED_BEFORE.test(text.slice(0, start))) continue;
+    return marker;
+  }
+
+  if (UNANSWERED.test(text)) return text.match(UNANSWERED)[0];
+
+  for (const hit of text.matchAll(/<([^<>]*)>/g)) {
+    if (isUnfilledSlot(hit[1])) return hit[0];
+  }
+
+  return null;
+}
 
 const PART_LABELS = {
   whereText: 'where',
@@ -142,6 +356,29 @@ export function inspectCriterion(criterion, { ordinal = null, id = null } = {})
     });
   }
 
+  // A `then` of at most three adjectives, with nothing in it to look for.
+  // Ordered after UNFALSIFIABLE_THEN and guarded on it, because "it works" is
+  // both, and one clause earning two findings reads as the check stuttering.
+  if (thenText && !findings.some((finding) => finding.code === 'unfalsifiable_then')) {
+    const words = thenText.split(' ').map((word) => word.replace(/[^a-z-]/g, ''));
+    const content = words.filter(Boolean);
+    if (
+      content.length > 0 &&
+      content.length <= 3 &&
+      !hasFalsifiableAnchor(criterion.thenText) &&
+      content.some((word) => VAGUE_QUALITY.has(word))
+    ) {
+      findings.push({
+        ...at,
+        code: 'adjectival_then',
+        field: 'thenText',
+        text: String(criterion.thenText).trim(),
+        detail:
+          'The observable result is a quality, not an observation — there is no value, count, state, or exact message in it for a reviewer to look for. Say what is on the screen or in the response.',
+      });
+    }
+  }
+
   const whereText = normalise(criterion?.whereText);
   if (whereText && UNLOCATED_WHERE.some((pattern) => pattern.test(whereText))) {
     findings.push({
@@ -152,17 +389,29 @@ export function inspectCriterion(criterion, { ordinal = null, id = null } = {})
       detail:
         'This names the whole product rather than a place to stand. Give the surface, environment, account, or role the next reviewer should check it on.',
     });
+  } else if (whereText && CATEGORICAL_WHERE.some((pattern) => pattern.test(whereText))) {
+    findings.push({
+      ...at,
+      code: 'categorical_where',
+      field: 'whereText',
+      text: String(criterion.whereText).trim(),
+      detail:
+        'This names a kind of place rather than one place. The next reviewer cannot stand in a category — name the specific surface, record, account, or route to open.',
+    });
   }
 
   for (const [field, label] of Object.entries(PART_LABELS)) {
     const raw = criterion?.[field];
-    if (typeof raw === 'string' && raw.trim() && PLACEHOLDER.test(raw)) {
+    if (typeof raw !== 'string') continue;
+    const marker = findPlaceholder(raw);
+    if (marker) {
       findings.push({
         ...at,
         code: 'placeholder_text',
         field,
         text: raw.trim(),
-        detail: `The ${label} clause still carries a placeholder. A criterion nobody has finished writing cannot be executed by somebody who did not write the code.`,
+        marker,
+        detail: `The ${label} clause still carries a placeholder (${marker}). A criterion nobody has finished writing cannot be executed by somebody who did not write the code.`,
       });
     }
   }

package/tools/work-hub/field-changes.js

@@ -0,0 +1,25 @@
+/** One authenticated read; unavailable history must never become an empty record. */
+export function registerWorkItemFieldChanges(server, { z, api, ok }) {
+  server.tool(
+    'get_work_item_field_changes',
+    'Read recorded edits to one card, newest first: field, previous and new values, actor, timestamp, reason and its source. Assignee names are current workspace directory labels; stored ids remain the historical values. Truncation is explicit. An empty result means no field changes were recorded, not that the card was never edited; older edits may predate recording. Reasons are the writer’s account, not independent QA evidence. Credential identifiers and worker capabilities are never returned.',
+    { itemId: z.string().describe('Card id.') },
+    async ({ itemId }) => {
+      const response = await api(
+        'GET',
+        `/api/v1/work-items/${encodeURIComponent(itemId)}/field-changes`
+      );
+      if (!Array.isArray(response?.data)) {
+        throw new Error(
+          'Field-change history was unavailable or malformed; no empty-history claim can be made.'
+        );
+      }
+      return ok({
+        count: response.data.length,
+        changes: response.data,
+        howToRead:
+          'Newest first. No rows means no recorded field changes; older edits may predate recording. A missing reason or identity was not recorded. Directory names are current labels for the stored assignee ids.',
+      });
+    }
+  );
+}

package/toolsets/prospecting.js

@@ -1,9 +1,10 @@
 /**
- * Prospecting Toolset (6 tools, Pro tier)
+ * Prospecting Toolset (9 tools, Pro tier)
  *
  * qualify_company, research_company, research_person,
  * get_priority_pursuits, get_speedrun_list (legacy alias), discover_prospects,
- * get_next_contacts
+ * get_next_contacts, commit_lead_to_outbound, release_lead_from_outbound,
+ * list_outbound_leads
  */
 
 import { z } from 'zod';
@@ -17,7 +18,19 @@ import {
   previewMarkdown, enrichCostLine,
   COMPANY_ENRICH_COST_SENTENCE, PERSON_ENRICH_COST_SENTENCE,
 } from '../governance/governed-args.js';
-import { governedWrite } from '../api-bridge.js';
+import { governedWrite, buildMutationHeaders } from '../api-bridge.js';
+
+/**
+ * The lead list that IS Pipeline's Outbound stage.
+ *
+ * `/targets` and Pipeline agree on who is committed by reading one list: the workspace's lead
+ * list whose `description` carries this marker. The display name is deliberately ordinary and
+ * deliberately NOT the identity — a user is free to make a list called "Outbound" for their own
+ * reasons, and it must never become product state. Mirrors `LEAD_COMMITMENT_MARKER` in
+ * `code/desktop/src/renderer/src/api/lead-commitment.ts`; `prospecting.test.js` pins the two to
+ * the same string because two packages cannot share the constant.
+ */
+export const LEAD_COMMITMENT_MARKER = 'starfield:sell:lead-commitment:v1';
 
 /**
  * Run the enrichment leg of a research tool through the governed-write
@@ -417,4 +430,182 @@ export function register(server, api, AUTH) {
       }
     }
   );
+
+  // -----------------------------------------------------------------------
+  // Outbound commitment — the /targets line, over MCP
+  //
+  // The leads surface has two halves: Outbound above the line, Targets below it. Crossing the
+  // line is ONE governed write — add or remove the person on the marker-owned lead list — and
+  // Pipeline's Outbound column reads that same list. These three tools are that gesture for an
+  // agent. They add no API surface: `POST/DELETE /lead-lists/{id}/members` existed and was in the
+  // bridge allowlist; what was missing was the knowledge of WHICH list, and a caller who reached
+  // for `add_to_lead_list` with the wrong id landed the person in a list the product never reads.
+  //
+  // The API's scope_guard maps `/lead-lists` writes onto `read:speedrun`
+  // (code/api/crates/middleware/src/scope_guard/mod.rs), which every issued grant carries, so the
+  // approval, reason and idempotency key are the whole gate here — and they are the same gate
+  // every other governed write in this server uses.
+  // -----------------------------------------------------------------------
+
+  /** The marker-owned Outbound list, or `null` — never a user's list that shares a display name. */
+  async function findOutboundList() {
+    const body = await api('GET', '/api/v1/lead-lists', { params: { limit: 500, page: 1 } });
+    const rows = Array.isArray(body?.data) ? body.data : [];
+    return rows.find((row) => row?.description === LEAD_COMMITMENT_MARKER) ?? null;
+  }
+
+  /** The Outbound members, named the way the members endpoint names them. */
+  async function outboundMembers(listId) {
+    const body = await api('GET', `/api/v1/lead-lists/${listId}/members`, {});
+    return Array.isArray(body?.data) ? body.data : [];
+  }
+
+  /** The refusal for a live write that lacks approval — checked BEFORE any step runs, because
+   *  the commit can carry a list-creation step and a refusal must leave nothing behind. */
+  function refuseIfUnapproved(args, method, path) {
+    if (!isLiveWrite(args)) return null;
+    const missing = missingLiveWriteFields(args);
+    if (missing.length === 0) return null;
+    // `isError` is the MCP-level flag a host reads; `mdError` alone only styles the text. A
+    // refused write that reads as a success envelope is how a caller retries with the same
+    // missing field — the communications pack sets it for the same reason.
+    return {
+      ...mdError(
+        `Live write refused — missing ${missing.join(', ')}`,
+        `Nothing was sent to ${method} ${path}. Re-call with dryRun:false plus ${missing.join(', ')}.`,
+      ),
+      isError: true,
+    };
+  }
+
+  server.tool(
+    'commit_lead_to_outbound',
+    'Commit a lead to Outbound. On /targets the Outbound half above the line IS Pipeline\'s Outbound stage, so this is the pipeline move for a person: it adds them to the workspace\'s marker-owned Outbound lead list, creating that list on the very first commitment. Use list_outbound_leads to read who is there and release_lead_from_outbound to take someone back out.' +
+      governedWriteNote('read:speedrun'),
+    {
+      personId: z.string().min(1).describe('The person (lead) to commit to Outbound'),
+      ...governedWriteArgs(z),
+    },
+    async (args) => {
+      try {
+        const list = await findOutboundList();
+        // A canonical placeholder segment, because the bridge refuses a non-pathname; the note
+        // beside it says what a live write does about the missing list.
+        const path = `/api/v1/lead-lists/${list ? list.id : 'new-outbound-list'}/members`;
+        const refused = refuseIfUnapproved(args, 'POST', path);
+        if (refused) return refused;
+
+        let listId = list?.id ?? null;
+        if (!listId && isLiveWrite(args)) {
+          // Same approval, same reason, same idempotency key as the member write that follows:
+          // the two requests are one decision, and neither route replays by key.
+          const created = await api('POST', '/api/v1/lead-lists', {
+            body: { name: 'Up Next', description: LEAD_COMMITMENT_MARKER },
+            headers: buildMutationHeaders(args),
+          });
+          listId = created?.data?.id;
+          if (!listId) throw new Error('creating the Outbound list returned no id');
+        }
+
+        const outcome = await governedWrite(api, args, {
+          method: 'POST',
+          path: listId ? `/api/v1/lead-lists/${listId}/members` : path,
+          body: { members: [{ personId: args.personId }] },
+          preview: {
+            entity: 'person',
+            entityId: args.personId,
+            operation: 'commit to Outbound (Pipeline Outbound stage)',
+            ...(list
+              ? {}
+              : {
+                  note:
+                    `The Outbound list does not exist yet in this workspace. A live write first creates it ` +
+                    `(POST /api/v1/lead-lists with description \`${LEAD_COMMITMENT_MARKER}\`), then adds the person.`,
+                }),
+          },
+        });
+        if (outcome.dryRun) return md(previewMarkdown('Commit to Outbound', outcome.preview));
+        return md(
+          `## Committed to Outbound\n\n` +
+            `- **Person:** ${args.personId}\n` +
+            `- **Outbound list:** ${listId}${list ? '' : ' (created on this write)'}\n` +
+            `- **Added:** ${outcome.result?.data?.added ?? 'reported by server'}\n\n` +
+            `The person now sits above the line on /targets and in Pipeline\'s Outbound stage.\n`,
+        );
+      } catch (err) {
+        return mdError('Commit to Outbound failed', err.message);
+      }
+    },
+  );
+
+  server.tool(
+    'release_lead_from_outbound',
+    'Take a lead back out of Outbound — below the line on /targets, out of Pipeline\'s Outbound stage. Removes the person from the marker-owned Outbound lead list; the person record itself is untouched.' +
+      governedWriteNote('read:speedrun'),
+    {
+      personId: z.string().min(1).describe('The person (lead) to release from Outbound'),
+      ...governedWriteArgs(z),
+    },
+    async (args) => {
+      try {
+        const list = await findOutboundList();
+        if (!list) {
+          return md(
+            `## Nothing to release\n\nThis workspace has no Outbound list yet — nobody has been committed, so ` +
+              `${args.personId} is already below the line. Nothing was written.\n`,
+          );
+        }
+        const path = `/api/v1/lead-lists/${list.id}/members/${encodeURIComponent(args.personId)}`;
+        const refused = refuseIfUnapproved(args, 'DELETE', path);
+        if (refused) return refused;
+        const outcome = await governedWrite(api, args, {
+          method: 'DELETE',
+          path,
+          preview: { entity: 'person', entityId: args.personId, operation: 'release from Outbound' },
+        });
+        if (outcome.dryRun) return md(previewMarkdown('Release from Outbound', outcome.preview));
+        return md(
+          `## Released from Outbound\n\n- **Person:** ${args.personId}\n- **Outbound list:** ${list.id}\n\n` +
+            `The person is below the line on /targets again and no longer in Pipeline\'s Outbound stage.\n`,
+        );
+      } catch (err) {
+        return mdError('Release from Outbound failed', err.message);
+      }
+    },
+  );
+
+  server.tool(
+    'list_outbound_leads',
+    'Who is committed to Outbound right now — the people above the line on /targets, which is Pipeline\'s Outbound stage. Read-only.',
+    {},
+    async () => {
+      try {
+        const list = await findOutboundList();
+        if (!list) {
+          return md(
+            `## Outbound\n\nThis workspace has no Outbound list yet: nobody has ever been committed to Outbound, ` +
+              `so there is nothing above the line. (Not a failed read — the list is created on the first commitment.)\n`,
+          );
+        }
+        const members = await outboundMembers(list.id);
+        if (members.length === 0) {
+          return md(`## Outbound — 0 committed\n\nThe Outbound list (${list.id}) exists and is empty: nobody is above the line.\n`);
+        }
+        const rows = members.map((m, i) => [
+          String(i + 1),
+          m.personName || m.personId || '\u2014',
+          m.personTitle || '\u2014',
+          m.personEmail || '\u2014',
+          m.personId || '\u2014',
+        ]);
+        return md(
+          `## Outbound — ${members.length} committed\n\n` +
+            table(['#', 'Person', 'Title', 'Email', 'Person ID'], rows) +
+            `\nOutbound list ${list.id}. Each row is above the line on /targets and in Pipeline\'s Outbound stage.\n`,
+        );
+      } catch (err) {
+        return mdError('Could not read Outbound', err.message);
+      }
+    },
+  );
 }

package/toolsets/revenue/always-loaded.js

@@ -12,9 +12,9 @@ import { getDemoAvailability } from '../../tools/scheduling.js';
 export const TOOLSET_REGISTRY = {
   prospecting: {
     name: 'prospecting',
-    description: 'Qualify companies, research prospects, get daily priorities, discover leads',
+    description: 'Qualify companies, research prospects, get daily priorities, discover leads, commit leads to Outbound',
     tier: 'pro',
-    toolCount: 6,
+    toolCount: 9,
   },
   intelligence: {
     name: 'intelligence',