fullstackgtm 0.43.0 → 0.44.0

package/dist/icp.js

@@ -54,6 +54,77 @@ export function icpToExploriumFilters(icp) {
         f.naics_category = { values: icp.firmographics.naics };
     return f;
 }
+/**
+ * Explorium /v1/businesses filters from the ICP — the COMPANY (account) side, for
+ * sizing the account universe (TAM). Firmographics only, no persona: the count is
+ * of matching companies. Field names differ from /v1/prospects (verified live):
+ * `country_code` (not company_country_code), `company_size` (same employee bands),
+ * `naics_category`. `/v1/businesses` total_results is a real count, capped at
+ * 60,000 (see EXPLORIUM_BUSINESS_COUNT_CAP in the connector).
+ */
+export function icpToExploriumBusinessFilters(icp) {
+    const f = {};
+    if (icp.firmographics.geos?.length)
+        f.country_code = { values: icp.firmographics.geos };
+    if (icp.firmographics.employeeBands?.length)
+        f.company_size = { values: icp.firmographics.employeeBands };
+    if (icp.firmographics.naics?.length)
+        f.naics_category = { values: icp.firmographics.naics };
+    return f;
+}
+/**
+ * Collapse provider-agnostic employee bands ("51-200","10001+") into a single
+ * {min,max} envelope for APIs that take integer bounds (TheirStack). An open
+ * top band ("10001+") leaves max undefined.
+ */
+export function employeeBandsToRange(bands) {
+    if (!bands?.length)
+        return {};
+    let min;
+    let max;
+    let openTop = false;
+    for (const band of bands) {
+        const plus = /^(\d+)\+$/.exec(band.trim());
+        if (plus) {
+            const lo = Number(plus[1]);
+            if (min === undefined || lo < min)
+                min = lo;
+            openTop = true;
+            continue;
+        }
+        const range = /^(\d+)\s*-\s*(\d+)$/.exec(band.trim());
+        if (range) {
+            const lo = Number(range[1]);
+            const hi = Number(range[2]);
+            if (min === undefined || lo < min)
+                min = lo;
+            if (max === undefined || hi > max)
+                max = hi;
+        }
+    }
+    return { min, max: openTop ? undefined : max };
+}
+/**
+ * TheirStack company-search filter from the ICP: the technographic targeting that
+ * Explorium can't do. `company_technology_slug_or` is the CRM/MAP buying signal
+ * (firmographics.technologies); employee bands become min/max bounds; geos become
+ * ISO2 codes (uppercased).
+ */
+export function icpToTheirStackFilters(icp) {
+    const f = {};
+    if (icp.firmographics.technologies?.length) {
+        f.company_technology_slug_or = icp.firmographics.technologies.map((t) => t.trim().toLowerCase());
+    }
+    if (icp.firmographics.geos?.length) {
+        f.company_country_code_or = icp.firmographics.geos.map((g) => g.trim().toUpperCase());
+    }
+    const range = employeeBandsToRange(icp.firmographics.employeeBands);
+    if (range.min !== undefined)
+        f.min_employee_count = range.min;
+    if (range.max !== undefined)
+        f.max_employee_count = range.max;
+    return f;
+}
 /**
  * Crustdata / LinkedIn seniority vocab. ICP job levels are normalized lowercase;
  * Crustdata expects these exact capitalized strings (verified: "CXO",
@@ -75,16 +146,31 @@ const CRUSTDATA_SENIORITY = {
     entry: "Entry",
 };
 /**
- * ICP industry keyword → LinkedIn industry names Crustdata filters on. Includes
- * the current LinkedIn-v2 names; for software we send the cluster (dev + IT
- * services + internet) so an OR match isn't overly narrow.
+ * ICP industry keyword → LinkedIn industry names Crustdata filters on.
+ *
+ * LinkedIn renamed its industry taxonomy (v1 → v2, ~2022), and data vendors
+ * normalize to one generation or the other. Sending ONLY the v2 names risks a
+ * zero-match when Crustdata stores v1 (and vice-versa) — observed live: a RevOps
+ * ICP whose only firmographic constraint was the v2 names returned 0 even though
+ * the title-only search returned plenty. So each cluster sends BOTH generations
+ * (OR-matched within the field): v2 ("Software Development", "IT Services and IT
+ * Consulting", "Technology, Information and Internet") AND v1 ("Computer
+ * Software", "Information Technology & Services", "Internet").
  */
 const CRUSTDATA_INDUSTRY = {
-    software: ["Software Development", "Information Technology and Services", "Internet"],
-    saas: ["Software Development", "Information Technology and Services"],
-    "information technology & services": ["Information Technology and Services"],
-    "information technology and services": ["Information Technology and Services"],
-    internet: ["Internet"],
+    software: [
+        "Software Development",
+        "Computer Software",
+        "IT Services and IT Consulting",
+        "Information Technology & Services",
+        "Information Technology and Services",
+        "Technology, Information and Internet",
+        "Internet",
+    ],
+    saas: ["Software Development", "Computer Software", "IT Services and IT Consulting", "Information Technology & Services"],
+    "information technology & services": ["Information Technology & Services", "IT Services and IT Consulting"],
+    "information technology and services": ["Information Technology & Services", "IT Services and IT Consulting"],
+    internet: ["Internet", "Technology, Information and Internet"],
     fintech: ["Financial Services"],
     "financial services": ["Financial Services"],
 };
@@ -92,9 +178,17 @@ const CRUSTDATA_INDUSTRY = {
  * pipe0 Crustdata people-search config.filters from the ICP. `current_job_titles`
  * matches real LinkedIn title strings (case-sensitive), so keywords are Title
  * Cased. Seniority + industry are mapped to Crustdata's controlled vocab via the
- * tables above. NOTE: the exact pipe0→Crustdata value set could not be re-run
- * live (pipe0 credits were exhausted) — validate when credits refill; fit
- * scoring is the safety net for persona precision regardless.
+ * tables above.
+ *
+ * LIVE FINDINGS (2026-06-26): `current_job_titles` is confirmed working (a
+ * titles-only RevOps search returns results); `current_title` is rejected (422).
+ * The full ICP filter returned 0 — the prime suspect is the industry vocab
+ * (LinkedIn v1/v2 taxonomy mismatch), now hedged by sending BOTH generations in
+ * CRUSTDATA_INDUSTRY above. NOT yet re-confirmed end-to-end (pipe0 credits were
+ * exhausted mid-investigation) — re-run `enrich acquire --source pipe0` once
+ * credits refill; if it still returns 0, the next suspects are the
+ * `current_seniority_levels` shape/values and `locations`. Note fit-scoring backs
+ * up PERSONA precision but NOT industry, so the industry filter is load-bearing.
  */
 export function icpToCrustdataFilters(icp) {
     const f = {};

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export { activeProfile, credentialsDir, credentialsPath, DEFAULT_PROFILE, delete
 export { generateDemoSnapshot, type DemoSnapshotOptions } from "./demo.ts";
 export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, type BuildEnrichPlanOptions, type EnrichAmbiguity, type EnrichConfig, type EnrichCounts, type EnrichFieldConfig, type EnrichMatchConfig, type EnrichMode, type EnrichObjectType, type EnrichPlanResult, type EnrichRun, type EnrichRunStore, type EnrichSourceConfig, type EnrichSourceRecord, type EnrichStamp, type EnrichWorkItem, type MatchOutcome, } from "./enrich.ts";
 export { scaffoldWorkspace, starterEnrichConfig, starterIcp, starterPlaybook, type InitProvider, type InitSource, type ScaffoldFile, type ScaffoldOptions, } from "./init.ts";
+export { appendCoverage, classifyAccount, classifyCoverage, computeCoverage, coverageCountsFromSnapshot, coveredAccounts, coverageToText, crmCheckableCriteria, deriveAcvFromClosedWon, deriveBuyersPerAccount, estimateTam, loadTamModel, projectEta, readCoverageTimeline, saveTamModel, tamDir, tamReportToMarkdown, type AccountTamClass, type AcvBasis, type DerivedAcv, type DerivedBuyers, type EstimateTamInput, type TamClassified, type TamCoverage, type TamCoverageCounts, type TamCrossCheck, type TamEta, type TamModel, type TamTargeting, type TamUniverse, } from "./tam.ts";
 export { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, type ApolloClient, type ApolloClientOptions, type ApolloPullKey, type ApolloPullResult, } from "./enrichApollo.ts";
 export { diffFindings, diffSnapshots, diffToMarkdown, type CollectionDiff, type FieldChange, type FindingsDrift, type RecordChange, type SnapshotDiff, } from "./diff.ts";
 export { mergeSnapshots, type MergeConflict, type MergeMatch, type MergeReport, type MergeSuggestion, } from "./merge.ts";

package/dist/index.js

@@ -14,6 +14,7 @@ export { activeProfile, credentialsDir, credentialsPath, DEFAULT_PROFILE, delete
 export { generateDemoSnapshot } from "./demo.js";
 export { buildEnrichPlan, createFileEnrichRunStore, DEFAULT_STALE_DAYS, ENRICH_CONFIG_FILE_NAME, enrichRunId, inferIngestObjectType, ingestKeyValue, latestStamps, loadEnrichConfig, matchSourceRecord, parseCsv, parseEnrichConfig, resolveCrmField, selectStaleWork, sourceValueAt, stagedSourceRecords, staleDaysFor, } from "./enrich.js";
 export { scaffoldWorkspace, starterEnrichConfig, starterIcp, starterPlaybook, } from "./init.js";
+export { appendCoverage, classifyAccount, classifyCoverage, computeCoverage, coverageCountsFromSnapshot, coveredAccounts, coverageToText, crmCheckableCriteria, deriveAcvFromClosedWon, deriveBuyersPerAccount, estimateTam, loadTamModel, projectEta, readCoverageTimeline, saveTamModel, tamDir, tamReportToMarkdown, } from "./tam.js";
 export { apolloPullKeysForAppend, apolloPullKeysForRefresh, createApolloClient, pullApolloRecords, } from "./enrichApollo.js";
 export { diffFindings, diffSnapshots, diffToMarkdown, } from "./diff.js";
 export { mergeSnapshots, } from "./merge.js";

package/dist/init.js

@@ -28,6 +28,9 @@ export function starterIcp() {
             industries: ["software", "saas"],
             employeeBands: ["51-200", "201-500", "501-1000"],
             geos: ["us"],
+            // Technographic targeting (the real RevOps signal): companies that USE a
+            // CRM/MAP. Drives `tam estimate|accounts --source theirstack`.
+            technologies: ["salesforce", "hubspot", "pipedrive"],
         },
         persona: {
             jobLevels: ["vp", "director", "manager"],

package/dist/judgeEval.d.ts

@@ -110,6 +110,13 @@ export declare function defaultJudgeFn(opts?: {
     icp?: Icp;
     now?: Date;
 }): EvalJudgeFn;
+/**
+ * The default golden set's clock. Every `firstSeen` below is relative to this
+ * instant, so grading MUST pin `now: new Date(DEFAULT_GOLDEN_NOW_ISO)` —
+ * grading against wall time lets freshness decay rot the "fresh → send" rows,
+ * and the gate starts failing on a calendar date instead of a code change.
+ */
+export declare const DEFAULT_GOLDEN_NOW_ISO = "2026-06-23T12:00:00.000Z";
 /**
  * A starter labeled set covering the four rubric corners, so `icp eval --golden
  * default` runs offline and the deterministic baseline passes it (>= the default

package/dist/judgeEval.js

@@ -85,7 +85,14 @@ export function defaultJudgeFn(opts = {}) {
 }
 // ---------------------------------------------------------------------------
 // The default golden set (ships inline so `icp eval --golden default` is free)
-const GOLD_NOW_ISO = "2026-06-23T12:00:00.000Z";
+/**
+ * The default golden set's clock. Every `firstSeen` below is relative to this
+ * instant, so grading MUST pin `now: new Date(DEFAULT_GOLDEN_NOW_ISO)` —
+ * grading against wall time lets freshness decay rot the "fresh → send" rows,
+ * and the gate starts failing on a calendar date instead of a code change.
+ */
+export const DEFAULT_GOLDEN_NOW_ISO = "2026-06-23T12:00:00.000Z";
+const GOLD_NOW_ISO = DEFAULT_GOLDEN_NOW_ISO;
 function goldSignal(over) {
     const domain = normalizeAccountDomain(over.accountDomain);
     return {

package/dist/runReport.d.ts

@@ -1,5 +1,31 @@
+/**
+ * Per-row finding for the hosted run timeline. IDs + issue type ONLY — no field
+ * values ever leave the CLI, keeping the audit's row data on the operator's side
+ * while still giving the dashboard navigable, filterable detail.
+ */
+export type RunFinding = {
+    objectType: string;
+    objectId: string;
+    severity: string;
+    ruleId: string;
+    field?: string;
+    operation?: string;
+};
+/**
+ * Where a run's findings live in the source CRM, so the dashboard can deep-link
+ * each record. `recordUrlBase` is the provider's record URL prefix; the
+ * dashboard appends the per-object path. Just an URL prefix — no record data.
+ */
+export type RunCrm = {
+    provider: string;
+    recordUrlBase: string;
+};
 /** A command annotates its headline metrics (merged). */
 export declare function reportCounts(values: Record<string, unknown>): void;
+/** A command reports per-row findings (IDs + issue type, no values). */
+export declare function reportFindings(values: RunFinding[]): void;
+/** A command reports the source CRM's record-URL base for dashboard deep-links. */
+export declare function reportCrm(value: RunCrm): void;
 /** A command annotates a structured event (plan saved, meter charged, …). */
 export declare function reportEvent(type: string, detail?: string): void;
 /**

package/dist/runReport.js

@@ -8,12 +8,25 @@
  * pure added value for users who granted it.
  */
 import { getCredential } from "./credentials.js";
+// Bound the fire-and-forget POST: a pathological audit could surface thousands
+// of findings; cap what we ship (counts still carry the true total).
+const MAX_REPORTED_FINDINGS = 2000;
 let counts;
+let findings;
+let crm;
 const events = [];
 /** A command annotates its headline metrics (merged). */
 export function reportCounts(values) {
     counts = { ...(counts ?? {}), ...values };
 }
+/** A command reports per-row findings (IDs + issue type, no values). */
+export function reportFindings(values) {
+    findings = values.slice(0, MAX_REPORTED_FINDINGS);
+}
+/** A command reports the source CRM's record-URL base for dashboard deep-links. */
+export function reportCrm(value) {
+    crm = value;
+}
 /** A command annotates a structured event (plan saved, meter charged, …). */
 export function reportEvent(type, detail) {
     events.push({ ts: Date.now(), type, detail });
@@ -54,6 +67,8 @@ export async function flushRunReport(args, status, startedAt, error) {
                 finishedAt,
                 durationMs: finishedAt - startedAt,
                 counts,
+                findings: findings?.length ? findings : undefined,
+                crm,
                 events: events.length ? events : undefined,
                 error,
             }),

package/dist/schedule.js

@@ -29,7 +29,13 @@ const SCHEDULABLE = {
     suggest: null,
     report: null,
     doctor: null,
-    enrich: ["append", "refresh"],
+    // `enrich append|refresh` fill blanks; `enrich acquire` creates net-new
+    // leads — but ONLY as a needs_approval `create_record` plan (`--save`,
+    // required below), never a write. This is what lets `tam populate` chip away
+    // at a TAM unattended: each firing queues a fresh lead plan, the meter is
+    // charged only at apply, and apply stays `apply --plan-id` (re-checked
+    // approved). So scheduled acquire accumulates proposals, never surprise leads.
+    enrich: ["append", "refresh", "acquire"],
     market: ["capture", "refresh"],
     // The GTM brain. `signals fetch` is read-only re: CRM (--save persists only
     // the local signal ledger). `icp judge`/`icp eval` are read-only/grade-only
@@ -41,9 +47,9 @@ const SCHEDULABLE = {
     icp: ["judge", "eval"],
     draft: null,
 };
-const ALLOWLIST_SUMMARY = "audit, snapshot, enrich append|refresh, market capture|refresh, signals fetch, " +
-    "icp judge|eval, draft (stages a plan), suggest, report, doctor — " +
-    "plus apply --plan-id <id> (re-checked approved at every firing)";
+const ALLOWLIST_SUMMARY = "audit, snapshot, enrich append|refresh, enrich acquire --save (stages a lead plan), " +
+    "market capture|refresh, signals fetch, icp judge|eval, draft (stages a plan), " +
+    "suggest, report, doctor — plus apply --plan-id <id> (re-checked approved at every firing)";
 /**
  * Validate that an argv resolves to a schedulable fullstackgtm command.
  * Enforced at `schedule add` time AND re-checked at `schedule run` time (the
@@ -89,6 +95,14 @@ export function validateSchedulableArgv(argv) {
                 .map((name) => `${head} ${name}`)
                 .join(", ")}.`);
         }
+        // `enrich acquire` is schedulable ONLY in its plan-producing form: without
+        // --save it's a dry-run that writes nothing AND queues nothing, so an
+        // unattended firing would silently no-op. Require --save so a scheduled
+        // acquire always leaves a needs_approval plan behind (apply stays gated).
+        if (head === "enrich" && sub === "acquire" && !argv.includes("--save")) {
+            throw new Error("Scheduled `enrich acquire` must include --save so each firing queues a needs_approval lead plan " +
+                "(without it the run produces nothing). Apply stays a separate human gate (`apply --plan-id <id>`).");
+        }
     }
 }
 /**

package/dist/signals.d.ts

@@ -132,6 +132,41 @@ export declare function buildSignalsFromAts(rawJobs: Array<AtsJob & {
     now?: Date;
     priorSignals?: Signal[];
 }): Signal[];
+/**
+ * One staged signal row: the platform-agnostic intake shape every NON-job source
+ * produces (a source connector's output, or a `--from` JSON row). It carries the
+ * evidence anchor (`quote`) but none of the derived fields (`id`, `weight`,
+ * `source`) — `stagedRowToSignal` fills those so there is ONE place that gates
+ * evidence and stamps identity, whether the row came from a file or an API.
+ */
+export type StagedSignalRow = {
+    bucket: SignalBucket;
+    accountDomain: string;
+    trigger: string;
+    /** VERBATIM evidence — required, non-empty. */
+    quote: string;
+    sourceUrl?: string;
+    /** ISO 8601; defaults to run time when absent. */
+    firstSeen?: string;
+    /** Optional explicit weight; defaults to the bucket's configured weight. */
+    weight?: number;
+};
+/**
+ * Validate one loosely-typed staged row and turn it into a `Signal`, applying
+ * the verbatim-evidence gate (a row with no quote is rejected, never faked) and
+ * the same id/normalization logic the ATS path uses. `errorLabel` lets the
+ * caller produce a precise message ("--from f.json: row 3", "serpapi-news row 0")
+ * since both the `--from` ingest and the source-connector registry funnel here.
+ *
+ * Throws on a malformed row; returns the canonical `Signal` on success. Bucket
+ * FILTERING (skip rows outside a `--bucket` selection) stays with the caller —
+ * this function is per-row validation only.
+ */
+export declare function stagedRowToSignal(entry: Record<string, unknown>, opts: {
+    now: Date;
+    source: string;
+    errorLabel: string;
+}): Signal;
 /**
  * Split candidate signals into fresh vs. deduped against prior signals. A
  * candidate is deduped when a prior signal shares its `dedupKey`
@@ -160,6 +195,25 @@ export declare function dedupeSignals(candidates: Signal[], priorSignals: Signal
  */
 export declare function computeWeights(config: SignalsConfig, outcomes: SignalOutcome[], signalsById?: Map<string, Signal>): Record<SignalBucket, number>;
 export declare function signalsDir(baseDir?: string): string;
+/**
+ * Conventional webhook landing zone: `<signals>/spool`, profile-scoped. A
+ * webhook receiver (hosted, or the operator's own glue) appends one JSONL row
+ * per event to a `*.jsonl` file here; `signals fetch --connector file` reads the
+ * whole directory when given no explicit path. The CLI never writes here — the
+ * receiver does — so this is just the agreed-upon location, not a managed store.
+ * Per-source files (`rb2b.jsonl`, `hubspot.jsonl`, …) coexist. See
+ * docs/signal-spool-format.md.
+ */
+export declare function signalsSpoolDir(baseDir?: string): string;
+/**
+ * Conventional outbox: `<signals>/outbox`, profile-scoped — the SEND-side mirror
+ * of the spool. `apply --channel outbox` renders each APPROVED drafted opener to
+ * a `<channel>.jsonl` file here (one row per touch); a downstream sender (hosted,
+ * or the operator's own) drains it. The CLI WRITES governed, approved send
+ * intents here but TRANSMITS NOTHING — the "drafts everything, transmits nothing"
+ * invariant holds. See docs/outbox-format.md.
+ */
+export declare function signalsOutboxDir(baseDir?: string): string;
 export type SignalRun = {
     id: string;
     runLabel: string;

package/dist/signals.js

@@ -292,6 +292,47 @@ function withinWindow(iso, now, windowDays) {
         return false;
     return now.getTime() - t <= windowDays * DAY_MS;
 }
+/**
+ * Validate one loosely-typed staged row and turn it into a `Signal`, applying
+ * the verbatim-evidence gate (a row with no quote is rejected, never faked) and
+ * the same id/normalization logic the ATS path uses. `errorLabel` lets the
+ * caller produce a precise message ("--from f.json: row 3", "serpapi-news row 0")
+ * since both the `--from` ingest and the source-connector registry funnel here.
+ *
+ * Throws on a malformed row; returns the canonical `Signal` on success. Bucket
+ * FILTERING (skip rows outside a `--bucket` selection) stays with the caller —
+ * this function is per-row validation only.
+ */
+export function stagedRowToSignal(entry, opts) {
+    const { now, source, errorLabel } = opts;
+    const bucket = String(entry.bucket ?? "");
+    if (!SIGNAL_BUCKETS.includes(bucket)) {
+        throw new Error(`${errorLabel} has unknown bucket "${bucket}" (one of ${SIGNAL_BUCKETS.join(", ")}).`);
+    }
+    const accountDomain = normalizeAccountDomain(String(entry.accountDomain ?? entry.domain ?? ""));
+    if (!accountDomain)
+        throw new Error(`${errorLabel} is missing accountDomain.`);
+    const trigger = String(entry.trigger ?? "").trim();
+    if (!trigger)
+        throw new Error(`${errorLabel} is missing trigger.`);
+    const quote = String(entry.quote ?? "").trim();
+    if (!quote)
+        throw new Error(`${errorLabel} is missing the verbatim quote (the evidence anchor).`);
+    const base = { accountDomain, bucket: bucket, trigger };
+    const firstSeen = typeof entry.firstSeen === "string" && entry.firstSeen ? entry.firstSeen : now.toISOString();
+    return {
+        id: signalId(base),
+        accountDomain,
+        bucket: bucket,
+        trigger,
+        quote,
+        sourceUrl: String(entry.sourceUrl ?? ""),
+        firstSeen,
+        weight: typeof entry.weight === "number" ? entry.weight : DEFAULT_SIGNALS_CONFIG.buckets[bucket].weight,
+        source,
+        judgedBy: null,
+    };
+}
 // ---------------------------------------------------------------------------
 // Dedup
 /**
@@ -392,6 +433,29 @@ function blankCounts() {
 export function signalsDir(baseDir) {
     return join(baseDir ?? credentialsDir(), "signals");
 }
+/**
+ * Conventional webhook landing zone: `<signals>/spool`, profile-scoped. A
+ * webhook receiver (hosted, or the operator's own glue) appends one JSONL row
+ * per event to a `*.jsonl` file here; `signals fetch --connector file` reads the
+ * whole directory when given no explicit path. The CLI never writes here — the
+ * receiver does — so this is just the agreed-upon location, not a managed store.
+ * Per-source files (`rb2b.jsonl`, `hubspot.jsonl`, …) coexist. See
+ * docs/signal-spool-format.md.
+ */
+export function signalsSpoolDir(baseDir) {
+    return join(signalsDir(baseDir), "spool");
+}
+/**
+ * Conventional outbox: `<signals>/outbox`, profile-scoped — the SEND-side mirror
+ * of the spool. `apply --channel outbox` renders each APPROVED drafted opener to
+ * a `<channel>.jsonl` file here (one row per touch); a downstream sender (hosted,
+ * or the operator's own) drains it. The CLI WRITES governed, approved send
+ * intents here but TRANSMITS NOTHING — the "drafts everything, transmits nothing"
+ * invariant holds. See docs/outbox-format.md.
+ */
+export function signalsOutboxDir(baseDir) {
+    return join(signalsDir(baseDir), "outbox");
+}
 export function signalRunId(runLabel) {
     return `sigr_${fnv1a(runLabel)}`;
 }