@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/ingestion/reconcile/calendar.js

@@ -0,0 +1,110 @@
+// "Has this event already happened, or was it called off?"
+//
+// The odd one out of the six, in two ways.
+//
+// FIRST, it is the only reconciler whose verdict depends on the CLOCK rather
+// than purely on what the source said. "Ended" is a comparison, not a field, so
+// this file is built by a factory that takes `now` and the registry member is
+// the one instance bound to the wall clock. Tests inject their own, which is
+// what keeps the whole suite free of `Date.now()` inside a reconciliation path.
+//
+// SECOND, the kind is `calendar` while the app slugs are `google_calendar` /
+// `googlecalendar` / `calendar`. The artifact axis names the artifact, not the
+// vendor; the slug bridge lives in `artifact-kind.ts` and nowhere else.
+//
+// An event with no readable end time is `unreachable`, never "not ended yet".
+// Guessing the second reading would leave a row standing forever, which is the
+// safe direction but for the wrong reason - and the wrong reason is what breaks
+// the next time somebody changes the guess.
+import { callMcpTool } from "./mcp-call.js";
+import { asBoolean, asNumber, asRecord, asString, metaUrl, pickFirst } from "./payload.js";
+/** ONE round-trip. The event, its status and its end time. */
+const CALENDAR_EVENT_TOOL = "GOOGLECALENDAR_GET_EVENT";
+/** Where the event body might live, unwrapped path first. */
+const EVENT_PATHS = ["event", "data.event", "data", "response_data"];
+/**
+ * The event id off the item's URL.
+ *
+ * Google's `eventedit/<base64>` and `?eid=<base64>` forms both carry an opaque
+ * blob that IS the id as far as the API is concerned, so neither is decoded -
+ * decoding would produce `<eventId> <calendarId>` and require guessing where to
+ * split.
+ */
+export function parseCalendarEventId(url) {
+    if (url === null)
+        return null;
+    const eid = /[?&]eid=([^&]+)/.exec(url);
+    if (eid?.[1])
+        return eid[1];
+    const edit = /\/eventedit\/([^/?#]+)/.exec(url);
+    if (edit?.[1])
+        return edit[1];
+    const event = /\/events?\/([^/?#]+)/.exec(url);
+    if (event?.[1])
+        return event[1];
+    return null;
+}
+/**
+ * An end time as epoch ms, from any of the three shapes Google emits.
+ *
+ * `end.dateTime` is a full timestamp; `end.date` is an all-day event's exclusive
+ * end date, which already means midnight at the start of the following day, so
+ * it needs no adjustment. A string `Date` cannot parse yields `null` rather than
+ * `NaN`, because `NaN < now` is `false` and would quietly read as "not ended".
+ */
+function endTimeMs(event) {
+    const direct = asNumber(pickFirst(event, ["endMs", "end_ms"]));
+    if (direct !== null)
+        return direct;
+    const raw = asString(pickFirst(event, ["end.dateTime", "end.date_time", "end.date", "endTime", "end_time", "end"]));
+    if (raw === null)
+        return null;
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+/**
+ * The registry member's factory, so `now` is an argument rather than a global.
+ *
+ * Signatures: `calendar:past:<eventId>`, `calendar:gone:<eventId>`.
+ */
+export function createCalendarReconciler(now) {
+    return async (target, ref, signal) => {
+        try {
+            const eventId = parseCalendarEventId(metaUrl(ref.meta));
+            if (eventId === null)
+                return { verdict: "unreachable", signature: null };
+            const payload = await callMcpTool(target, CALENDAR_EVENT_TOOL, { event_id: eventId }, signal);
+            if (payload === null)
+                return { verdict: "unreachable", signature: null };
+            // A DEFINITE 404 the server reported, not a read that failed to answer.
+            const notFound = asBoolean(pickFirst(payload, ["not_found", "data.not_found", "deleted"]));
+            if (notFound === true) {
+                return { verdict: "artifact-gone", signature: `calendar:gone:${eventId}` };
+            }
+            const event = asRecord(pickFirst(payload, [...EVENT_PATHS]));
+            if (!event)
+                return { verdict: "unreachable", signature: null };
+            // CANCELLED first: a called-off meeting may well have an end time in the
+            // past, and reading the clock before the status would file it as "you
+            // attended it".
+            const status = asString(pickFirst(event, ["status", "state"]))?.toLowerCase() ?? null;
+            if (status === "cancelled" || status === "canceled") {
+                return { verdict: "artifact-gone", signature: `calendar:gone:${eventId}` };
+            }
+            const ends = endTimeMs(event);
+            // No readable end time. Not "still upcoming".
+            if (ends === null)
+                return { verdict: "unreachable", signature: null };
+            if (ends <= now()) {
+                return { verdict: "handled-elsewhere", signature: `calendar:past:${eventId}` };
+            }
+            return { verdict: "pending", signature: null };
+        }
+        catch {
+            return { verdict: "unreachable", signature: null };
+        }
+    };
+}
+/** The registry member. The wall clock is bound HERE and nowhere deeper. */
+export const calendarReconciler = createCalendarReconciler(() => Date.now());
+//# sourceMappingURL=calendar.js.map

package/dist/server/server/ingestion/reconcile/constants.d.ts

@@ -0,0 +1,60 @@
+/**
+ * How long a verification stamp is trusted before a re-read is owed.
+ *
+ * A HYPOTHESIS, NOT A SETTING. Nobody has measured what a Gmail or GitLab MCP
+ * read costs in this deployment yet, so this number is a starting point chosen
+ * to be obviously safe rather than obviously right. `snapshotReadLatency()`
+ * exists to replace it: re-pick this from the observed per-slug p50/p95 after
+ * the first week of real data.
+ *
+ * Consumed by `ReconciliationService.verifyIfStale` as the default when
+ * `ingestionReconcileStaleMs` is absent from daemon config.
+ */
+export declare const RECONCILE_STALE_MS = 60000;
+/**
+ * How long a single source read may take before the service calls it unreachable.
+ *
+ * Also a HYPOTHESIS. Same instrument, same re-pick: if p95 for a slug sits near
+ * this number, the timeout is manufacturing `unreachable` verdicts out of a slow
+ * but working source.
+ *
+ * Consumed by `ReconciliationService.readOne`, through a `Promise.race` rather
+ * than through the reconciler's `AbortSignal` - a reconciler that ignores its
+ * signal must not be able to hang the pool.
+ */
+export declare const RECONCILE_TIMEOUT_MS = 10000;
+/**
+ * Peak concurrent source reads across ONE `verifyIfStale` call.
+ *
+ * Global to the call, not per source group: four groups each capped at four
+ * would be sixteen concurrent reads against aggregators that rate-limit.
+ *
+ * Consumed by `ReconciliationService`'s worker pool.
+ */
+export declare const RECONCILE_MAX_CONCURRENCY = 4;
+/**
+ * Consecutive `unreachable` verdicts before an item's re-reads are backed off.
+ *
+ * DECLARED HERE, CONSUMED BY STORY 6.2. This story increments
+ * `reconcile_fail_count` and stops there; the policy that reads the counter and
+ * decides to stop asking is 6.2's. It lives here so 6.2 adds no second constants
+ * file and the threshold and its backoff window stay adjacent.
+ */
+export declare const RECONCILE_UNREACHABLE_THRESHOLD = 3;
+/**
+ * How long an item parks after crossing `RECONCILE_UNREACHABLE_THRESHOLD`.
+ *
+ * DECLARED HERE, CONSUMED BY STORY 6.2. This is the RECONCILE backoff and has
+ * nothing to do with Epic 3's `BACKOFF_COOLDOWN_MS` dispatch window - the two
+ * counters are separate on purpose (epic D5) and so are their windows.
+ */
+export declare const RECONCILE_UNREACHABLE_BACKOFF_MS = 900000;
+/**
+ * Minimum gap between latency-snapshot log lines.
+ *
+ * Consumed by `ReconciliationService`. The snapshot is the input for re-picking
+ * `RECONCILE_STALE_MS` and `RECONCILE_TIMEOUT_MS`, so it has to reach the logs;
+ * emitting it per call would bury it.
+ */
+export declare const RECONCILE_TELEMETRY_INTERVAL_MS = 300000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/server/server/ingestion/reconcile/constants.js

@@ -0,0 +1,62 @@
+// The five epic constants plus the telemetry interval, in ONE file, so Story 6.2
+// adds no second constants module and the two stories cannot drift.
+/**
+ * How long a verification stamp is trusted before a re-read is owed.
+ *
+ * A HYPOTHESIS, NOT A SETTING. Nobody has measured what a Gmail or GitLab MCP
+ * read costs in this deployment yet, so this number is a starting point chosen
+ * to be obviously safe rather than obviously right. `snapshotReadLatency()`
+ * exists to replace it: re-pick this from the observed per-slug p50/p95 after
+ * the first week of real data.
+ *
+ * Consumed by `ReconciliationService.verifyIfStale` as the default when
+ * `ingestionReconcileStaleMs` is absent from daemon config.
+ */
+export const RECONCILE_STALE_MS = 60000;
+/**
+ * How long a single source read may take before the service calls it unreachable.
+ *
+ * Also a HYPOTHESIS. Same instrument, same re-pick: if p95 for a slug sits near
+ * this number, the timeout is manufacturing `unreachable` verdicts out of a slow
+ * but working source.
+ *
+ * Consumed by `ReconciliationService.readOne`, through a `Promise.race` rather
+ * than through the reconciler's `AbortSignal` - a reconciler that ignores its
+ * signal must not be able to hang the pool.
+ */
+export const RECONCILE_TIMEOUT_MS = 10000;
+/**
+ * Peak concurrent source reads across ONE `verifyIfStale` call.
+ *
+ * Global to the call, not per source group: four groups each capped at four
+ * would be sixteen concurrent reads against aggregators that rate-limit.
+ *
+ * Consumed by `ReconciliationService`'s worker pool.
+ */
+export const RECONCILE_MAX_CONCURRENCY = 4;
+/**
+ * Consecutive `unreachable` verdicts before an item's re-reads are backed off.
+ *
+ * DECLARED HERE, CONSUMED BY STORY 6.2. This story increments
+ * `reconcile_fail_count` and stops there; the policy that reads the counter and
+ * decides to stop asking is 6.2's. It lives here so 6.2 adds no second constants
+ * file and the threshold and its backoff window stay adjacent.
+ */
+export const RECONCILE_UNREACHABLE_THRESHOLD = 3;
+/**
+ * How long an item parks after crossing `RECONCILE_UNREACHABLE_THRESHOLD`.
+ *
+ * DECLARED HERE, CONSUMED BY STORY 6.2. This is the RECONCILE backoff and has
+ * nothing to do with Epic 3's `BACKOFF_COOLDOWN_MS` dispatch window - the two
+ * counters are separate on purpose (epic D5) and so are their windows.
+ */
+export const RECONCILE_UNREACHABLE_BACKOFF_MS = 900000;
+/**
+ * Minimum gap between latency-snapshot log lines.
+ *
+ * Consumed by `ReconciliationService`. The snapshot is the input for re-picking
+ * `RECONCILE_STALE_MS` and `RECONCILE_TIMEOUT_MS`, so it has to reach the logs;
+ * emitting it per call would bury it.
+ */
+export const RECONCILE_TELEMETRY_INTERVAL_MS = 300000;
+//# sourceMappingURL=constants.js.map

package/dist/server/server/ingestion/reconcile/github.d.ts

@@ -0,0 +1,21 @@
+import type { Reconciler } from "./types.js";
+export interface GithubPullRequestRef {
+    owner: string;
+    repo: string;
+    number: string;
+}
+/**
+ * `https://github.com/owner/repo/pull/7` -> `{ owner, repo, number: "7" }`.
+ *
+ * `/pull/` only. An issue URL (`/issues/7`) is deliberately NOT accepted: a
+ * closed issue is not a merged PR, and quietly reconciling one as the other is
+ * how a row closes on the wrong artifact's semantics.
+ */
+export declare function parseGithubUrl(url: string | null): GithubPullRequestRef | null;
+/**
+ * Signatures: `pr:merged:<sha12>`, `pr:closed:<number>`, `pr:gone:<number>`.
+ *
+ * No owner, no repo, no title. The row already knows where it came from.
+ */
+export declare const githubReconciler: Reconciler;
+//# sourceMappingURL=github.d.ts.map

package/dist/server/server/ingestion/reconcile/github.js

@@ -0,0 +1,83 @@
+// Precedent: packages/server/src/server/auto-archive-on-merge/archive-if-safe.ts:62
+// (the isMerged gate) and :78-82 (a failed read skips, it never acts).
+//
+// "Did somebody merge or close this PR without paseo?"
+//
+// GitHub gives the answer twice - a boolean `merged` and a `state` string - and
+// this file reads both, because they disagree in one direction that matters: a
+// merged PR reports `state: "closed"`, so reading the string alone would file
+// every merge under "closed" and lose the merge SHA that is the evidence. The
+// boolean is checked first for exactly that reason.
+import { callMcpTool } from "./mcp-call.js";
+import { asBoolean, asRecord, asString, metaUrl, pickFirst } from "./payload.js";
+/** ONE round-trip. The PR, its state, its merged flag and its merge SHA. */
+const GITHUB_PR_TOOL = "GITHUB_GET_A_PULL_REQUEST";
+/** Where the pull request body might live, unwrapped path first. */
+const PR_PATHS = ["pull_request", "data.pull_request", "data", "response_data"];
+const SHA_SIGNATURE_LENGTH = 12;
+/**
+ * `https://github.com/owner/repo/pull/7` -> `{ owner, repo, number: "7" }`.
+ *
+ * `/pull/` only. An issue URL (`/issues/7`) is deliberately NOT accepted: a
+ * closed issue is not a merged PR, and quietly reconciling one as the other is
+ * how a row closes on the wrong artifact's semantics.
+ */
+export function parseGithubUrl(url) {
+    if (url === null)
+        return null;
+    const match = /^https?:\/\/[^/]+\/([^/]+)\/([^/]+)\/pull\/(\d+)/.exec(url);
+    const owner = match?.[1];
+    const repo = match?.[2];
+    const number = match?.[3];
+    if (!owner || !repo || !number)
+        return null;
+    return { owner, repo, number };
+}
+/**
+ * Signatures: `pr:merged:<sha12>`, `pr:closed:<number>`, `pr:gone:<number>`.
+ *
+ * No owner, no repo, no title. The row already knows where it came from.
+ */
+export const githubReconciler = async (target, ref, signal) => {
+    try {
+        const parsed = parseGithubUrl(metaUrl(ref.meta));
+        if (parsed === null)
+            return { verdict: "unreachable", signature: null };
+        const payload = await callMcpTool(target, GITHUB_PR_TOOL, { owner: parsed.owner, repo: parsed.repo, pull_number: Number(parsed.number) }, signal);
+        if (payload === null)
+            return { verdict: "unreachable", signature: null };
+        // A DEFINITE 404 the server reported, not a read that failed to answer.
+        const notFound = asBoolean(pickFirst(payload, ["not_found", "data.not_found", "deleted"]));
+        if (notFound === true) {
+            return { verdict: "artifact-gone", signature: `pr:gone:${parsed.number}` };
+        }
+        const pr = asRecord(pickFirst(payload, [...PR_PATHS]));
+        if (!pr)
+            return { verdict: "unreachable", signature: null };
+        // FIRST, because a merged PR also reports `state: "closed"` and the string
+        // alone would lose the merge.
+        if (asBoolean(pickFirst(pr, ["merged", "is_merged", "merged_at_present"])) === true) {
+            const sha = asString(pickFirst(pr, ["merge_commit_sha", "merged_commit_sha", "sha"]));
+            return {
+                verdict: "handled-elsewhere",
+                signature: sha === null
+                    ? `pr:merged:${parsed.number}`
+                    : `pr:merged:${sha.slice(0, SHA_SIGNATURE_LENGTH)}`,
+            };
+        }
+        const state = asString(pickFirst(pr, ["state", "status"]))?.toLowerCase() ?? null;
+        if (state === null)
+            return { verdict: "unreachable", signature: null };
+        if (state === "closed") {
+            return { verdict: "handled-elsewhere", signature: `pr:closed:${parsed.number}` };
+        }
+        if (state === "open" || state === "opened" || state === "draft") {
+            return { verdict: "pending", signature: null };
+        }
+        return { verdict: "unreachable", signature: null };
+    }
+    catch {
+        return { verdict: "unreachable", signature: null };
+    }
+};
+//# sourceMappingURL=github.js.map

package/dist/server/server/ingestion/reconcile/gitlab.d.ts

@@ -0,0 +1,23 @@
+import type { Reconciler } from "./types.js";
+export interface GitlabMergeRequestRef {
+    projectPath: string;
+    iid: string;
+}
+/**
+ * `https://gitlab.example.com/group/sub/project/-/merge_requests/42` ->
+ * `{ projectPath: "group/sub/project", iid: "42" }`.
+ *
+ * Split on the `/-/` infix rather than counting path segments, because GitLab
+ * groups nest arbitrarily deep and a fixed segment count silently mis-parses
+ * every subgroup project. A URL without the infix, or with a non-numeric iid,
+ * yields `null` and therefore `unreachable`.
+ */
+export declare function parseGitlabUrl(url: string | null): GitlabMergeRequestRef | null;
+/**
+ * Signatures: `mr:merged:<sha12>`, `mr:closed:<iid>`, `mr:gone:<iid>`.
+ *
+ * A project path is deliberately absent from all three. It is already implied by
+ * the row, and a signature is a short fact rather than a location.
+ */
+export declare const gitlabReconciler: Reconciler;
+//# sourceMappingURL=gitlab.d.ts.map

package/dist/server/server/ingestion/reconcile/gitlab.js

@@ -0,0 +1,94 @@
+// Precedent: packages/server/src/server/auto-archive-on-merge/archive-if-safe.ts:62
+// (the isMerged gate) and :78-82 (a failed read skips, it never acts).
+//
+// "Did somebody merge or close this MR without paseo?"
+//
+// `archive-if-safe.ts:62` is `if (!pullRequest?.isMerged) return;` - a gate that
+// acts only on a definite positive and treats every other reading, including a
+// null pull request, as "do nothing". This file is that gate with a verdict
+// instead of a return, and the `state` string is read the same way: `merged` and
+// `closed` act, `opened` is `pending`, and anything else - a state string nobody
+// anticipated, a missing field, a body that is not a merge request - is
+// `unreachable`.
+import { callMcpTool } from "./mcp-call.js";
+import { asBoolean, asRecord, asString, metaUrl, pickFirst } from "./payload.js";
+/** ONE round-trip. The MR, its state, and its merge commit if it has one. */
+const GITLAB_MR_TOOL = "GITLAB_GET_SINGLE_MERGE_REQUEST";
+/** Where the merge request body might live, unwrapped path first. */
+const MR_PATHS = ["merge_request", "data.merge_request", "data", "response_data"];
+/** Git SHAs are 40 hex characters; a signature carries the readable prefix only. */
+const SHA_SIGNATURE_LENGTH = 12;
+/**
+ * `https://gitlab.example.com/group/sub/project/-/merge_requests/42` ->
+ * `{ projectPath: "group/sub/project", iid: "42" }`.
+ *
+ * Split on the `/-/` infix rather than counting path segments, because GitLab
+ * groups nest arbitrarily deep and a fixed segment count silently mis-parses
+ * every subgroup project. A URL without the infix, or with a non-numeric iid,
+ * yields `null` and therefore `unreachable`.
+ */
+export function parseGitlabUrl(url) {
+    if (url === null)
+        return null;
+    const match = /^https?:\/\/[^/]+\/(.+?)\/-\/merge_requests\/(\d+)/.exec(url);
+    const projectPath = match?.[1];
+    const iid = match?.[2];
+    if (!projectPath || !iid)
+        return null;
+    return { projectPath, iid };
+}
+/**
+ * Signatures: `mr:merged:<sha12>`, `mr:closed:<iid>`, `mr:gone:<iid>`.
+ *
+ * A project path is deliberately absent from all three. It is already implied by
+ * the row, and a signature is a short fact rather than a location.
+ */
+export const gitlabReconciler = async (target, ref, signal) => {
+    try {
+        const parsed = parseGitlabUrl(metaUrl(ref.meta));
+        if (parsed === null)
+            return { verdict: "unreachable", signature: null };
+        const payload = await callMcpTool(target, GITLAB_MR_TOOL, { project_id: parsed.projectPath, merge_request_iid: Number(parsed.iid) }, signal);
+        if (payload === null)
+            return { verdict: "unreachable", signature: null };
+        // A DEFINITE 404 on an id that previously resolved is the one absence this
+        // epic accepts as evidence, because the server said it rather than failing
+        // to answer. It arrives as an explicit flag on a successful tool result, not
+        // as a missing field.
+        const notFound = asBoolean(pickFirst(payload, ["not_found", "data.not_found", "deleted"]));
+        if (notFound === true) {
+            return { verdict: "artifact-gone", signature: `mr:gone:${parsed.iid}` };
+        }
+        const mr = asRecord(pickFirst(payload, [...MR_PATHS]));
+        if (!mr)
+            return { verdict: "unreachable", signature: null };
+        const state = asString(pickFirst(mr, ["state", "status"]))?.toLowerCase() ?? null;
+        if (state === null)
+            return { verdict: "unreachable", signature: null };
+        if (state === "merged") {
+            const sha = asString(pickFirst(mr, ["merge_commit_sha", "sha", "squash_commit_sha"]));
+            // Merged with no SHA to cite. The state string alone is a definite
+            // positive, so this still closes; the signature falls back to the iid
+            // rather than inventing a hash.
+            return {
+                verdict: "handled-elsewhere",
+                signature: sha === null
+                    ? `mr:merged:${parsed.iid}`
+                    : `mr:merged:${sha.slice(0, SHA_SIGNATURE_LENGTH)}`,
+            };
+        }
+        if (state === "closed") {
+            return { verdict: "handled-elsewhere", signature: `mr:closed:${parsed.iid}` };
+        }
+        if (state === "opened" || state === "open" || state === "locked") {
+            return { verdict: "pending", signature: null };
+        }
+        // A state string nobody anticipated. Enumerate what you silence: an unknown
+        // state comes out as "paseo does not know", never as a close.
+        return { verdict: "unreachable", signature: null };
+    }
+    catch {
+        return { verdict: "unreachable", signature: null };
+    }
+};
+//# sourceMappingURL=gitlab.js.map

package/dist/server/server/ingestion/reconcile/gmail.d.ts

@@ -0,0 +1,9 @@
+import type { Reconciler } from "./types.js";
+/**
+ * Signature: `gmail:sent:<messageId>` or `gmail:draft-gone:<draftId>`.
+ *
+ * Both are opaque Gmail ids. No subject line, no body, no participant, no email
+ * address - `assertSafeSignature` is the enforcement, this is the intent.
+ */
+export declare const gmailReconciler: Reconciler;
+//# sourceMappingURL=gmail.d.ts.map

package/dist/server/server/ingestion/reconcile/gmail.js

@@ -0,0 +1,141 @@
+// Precedent: packages/server/src/server/auto-archive-on-merge/archive-if-safe.ts:62
+// (the isMerged gate - act only on a definite positive) and :78-82 (a failed read
+// skips, it never acts).
+//
+// "Did the human send this from Gmail instead of letting the agent send it?"
+//
+// The close requires TWO facts, not one, and the pairing is the whole safety
+// argument. A draft that no longer resolves could mean either of two very
+// different things:
+//
+//   the user sent it        -> the obligation is discharged, close the row
+//   the user deleted it     -> the artifact is gone, close the row differently
+//   the read simply failed  -> paseo knows nothing, LEAVE THE ROW STANDING
+//
+// so "no draft" alone is never enough. A close needs a definite positive: either
+// a `SENT` message on the thread (handled-elsewhere) or a successful read that
+// positively reports the draft absent (artifact-gone). An empty result array, a
+// null field or a missing key is the third case and returns `unreachable`.
+import { callMcpTool } from "./mcp-call.js";
+import { asArray, asRecord, asString, metaUrl, pickFirst } from "./payload.js";
+/**
+ * The Composio-style tool slug this reconciler calls.
+ *
+ * ONE `callTool` per read, on purpose: two round-trips would double the latency
+ * a `void verifyIfStale` is hiding behind the Inbox's first paint, and would
+ * introduce a window in which the draft and the thread were read at different
+ * instants - which is exactly how "sent" and "deleted" get confused.
+ *
+ * The tool is expected to return the thread, with its messages and any drafts
+ * still attached to it. A server whose payload carries neither is a server this
+ * reconciler cannot read, and that is `unreachable`.
+ */
+const GMAIL_THREAD_TOOL = "GMAIL_FETCH_MESSAGE_BY_THREAD_ID";
+/** Where the thread body might live, unwrapped path first. */
+const THREAD_PATHS = ["thread", "data.thread", "data", "response_data.thread"];
+/**
+ * The Gmail draft id carried on the item's own URL.
+ *
+ * `#drafts/<id>`, `#drafts?compose=<id>` and `/mail/u/0/#inbox/<id>` are all in
+ * the wild. The last path segment after the fragment is the id in every one of
+ * them, so the parse is deliberately structural rather than a per-shape regex
+ * zoo: a shape nobody anticipated yields `null`, and `null` is `unreachable`.
+ */
+function draftIdFrom(url) {
+    if (url === null)
+        return null;
+    const fragment = url.split("#")[1];
+    if (!fragment)
+        return null;
+    const compose = /[?&]compose=([^&]+)/.exec(fragment);
+    if (compose?.[1])
+        return decodeURIComponent(compose[1]);
+    const segments = fragment.split("/").filter((segment) => segment.length > 0);
+    const last = segments.at(-1);
+    return last && last.length > 0 ? decodeURIComponent(last) : null;
+}
+/**
+ * Does the thread still hold a draft with this id?
+ *
+ * Three-valued on purpose: `true`, `false`, or `null` for "the payload did not
+ * say". Collapsing `null` into `false` is the single line of code that would
+ * turn every unreadable Gmail response into a closed row.
+ */
+function draftStillPresent(thread, draftId) {
+    const drafts = asArray(pickFirst(thread, ["drafts", "draft_list"]));
+    if (drafts === null)
+        return null;
+    for (const entry of drafts) {
+        const record = asRecord(entry);
+        if (!record)
+            continue;
+        if (asString(pickFirst(record, ["id", "draftId", "draft_id"])) === draftId)
+            return true;
+    }
+    return false;
+}
+/**
+ * The id of the first message on the thread labelled `SENT`, or null.
+ *
+ * The message id, never the subject, never a recipient, never a body. This value
+ * goes straight into `verified_signature`, which is persisted and rendered.
+ */
+function sentMessageId(thread) {
+    const messages = asArray(pickFirst(thread, ["messages", "message_list"]));
+    if (messages === null)
+        return null;
+    for (const entry of messages) {
+        const record = asRecord(entry);
+        if (!record)
+            continue;
+        const labels = asArray(pickFirst(record, ["labelIds", "label_ids", "labels"]));
+        if (!labels?.some((label) => asString(label)?.toUpperCase() === "SENT"))
+            continue;
+        const id = asString(pickFirst(record, ["id", "messageId", "message_id"]));
+        if (id !== null)
+            return id;
+    }
+    return null;
+}
+/**
+ * Signature: `gmail:sent:<messageId>` or `gmail:draft-gone:<draftId>`.
+ *
+ * Both are opaque Gmail ids. No subject line, no body, no participant, no email
+ * address - `assertSafeSignature` is the enforcement, this is the intent.
+ */
+export const gmailReconciler = async (target, ref, signal) => {
+    try {
+        const draftId = draftIdFrom(metaUrl(ref.meta));
+        // No id means no read is possible. NOT a close: an item whose URL paseo
+        // could not parse is an item paseo cannot verify.
+        if (draftId === null)
+            return { verdict: "unreachable", signature: null };
+        const payload = await callMcpTool(target, GMAIL_THREAD_TOOL, { draftId }, signal);
+        if (payload === null)
+            return { verdict: "unreachable", signature: null };
+        const thread = asRecord(pickFirst(payload, [...THREAD_PATHS]));
+        if (!thread)
+            return { verdict: "unreachable", signature: null };
+        const present = draftStillPresent(thread, draftId);
+        // The payload did not tell us about drafts at all. Not "there are none".
+        if (present === null)
+            return { verdict: "unreachable", signature: null };
+        if (present)
+            return { verdict: "pending", signature: null };
+        const sentId = sentMessageId(thread);
+        if (sentId !== null) {
+            return { verdict: "handled-elsewhere", signature: `gmail:sent:${sentId}` };
+        }
+        // The draft positively resolved absent and no sent counterpart exists on the
+        // thread: the user deleted it. The obligation is gone either way, but the
+        // signature says which, because "sent" and "discarded" are different facts.
+        return { verdict: "artifact-gone", signature: `gmail:draft-gone:${draftId}` };
+    }
+    catch {
+        // Belt and braces over `callMcpTool`'s own swallow. A throw escaping here
+        // would reach `Promise.allSettled` and be indistinguishable from a rejected
+        // sibling's failure.
+        return { verdict: "unreachable", signature: null };
+    }
+};
+//# sourceMappingURL=gmail.js.map

package/dist/server/server/ingestion/reconcile/jira.d.ts

@@ -0,0 +1,17 @@
+import type { Reconciler } from "./types.js";
+/**
+ * `https://acme.atlassian.net/browse/ABC-123` -> `ABC-123`.
+ *
+ * `/browse/` is the canonical issue URL and the only form accepted. A key is
+ * uppercase letters/digits, a hyphen and a number; anything else is a URL this
+ * reconciler cannot address, which is `unreachable` rather than a guess.
+ */
+export declare function parseJiraIssueKey(url: string | null): string | null;
+/**
+ * Signatures: `jira:done:<key>`, `jira:gone:<key>`.
+ *
+ * The issue key and nothing else. A summary is prose and would be the PII leak
+ * `assertSafeSignature` cannot catch, because a sentence is not credential-shaped.
+ */
+export declare const jiraReconciler: Reconciler;
+//# sourceMappingURL=jira.d.ts.map