Timeline shows each event once, under one person

The idea

When a webhook and several collectors record the same GitHub change, Crewshal Timeline shows it once, with a count of its sources, and every record stays in the audit log. A login that a collector states for a person shows as that person on every path, the webhook too. Nothing is matched by name.

The problem
Overlapping sources would show one change several times.
Why it matters
Feeds and counts stay accurate as sources are added.
Where it stands
In production as of Two production checks with operator test accounts and scripted reports and webhook deliveries; no outside team has used it yet.

Crewshal team · · 4 min read

Recorded run · Production, operator test accounts · November 14, 2026

Does one change show once, under one person?

Three records of one merge become one entry, and a webhook login shows as the person that the collectors named.

Step 1 of 8Records arrive

Collector-style reportsTwo reports of one merge

A test account starts a Timeline-only organization. The check then sends what the collectors of two teammates would send for one change: two reports of the merge of pull request 7, each with its own delivery key and both with the same source id, the provider's own id of that merge. A third report is a near miss: the merge of pull request 8, with its own source id. All 3 reports are recorded.

InputReports sent

  • Report A: Carol Q merged pull request 7 (source id: the merge of 7)
  • Report B: Carol Q merged pull request 7 (source id: the merge of 7)
  • Near miss: Carol Q merged pull request 8 (source id: the merge of 8)

CheckRecorded checks

  • Timeline-only organizationPassed
  • Three reports recorded, none as a repeatPassed

Where it ran. Two checks in production at crewshal.com on the same day, 13:25:29 and 14:43:44 UTC, each with its own operator test account in a Timeline-only organization, erased afterwards. The checks sent collector-style reports through the public report API and signed webhook deliveries through a connection with their own secret; no real repository or teammate sent them.

The recorded files behind this replay
  • Production check: one event, 13 checks sha256 e16072bc3b74
  • The one-event check script (the reports and the webhook it sent) sha256 efffc4e0aaf2
  • Release note: one event shows once sha256 c7c588af5d7c
  • Production capture: the feed after the one-event check sha256 5ed87347cb8c
  • Production check: one identity, 9 checks sha256 7c6745b20112
  • The identity check script (stated logins, then webhooks) sha256 5647ccb59c3e
  • Release note: one identity on every path sha256 ca1820772728
  • Production capture: the feed after the identity check sha256 72305621abf8

Why it matters

Timeline is an automatic feed of what each person, outside agent, AI worker or automation did across connected systems. Nobody reports into it, and it needs no AI worker.

Real teams have sources that overlap. Two teammates' collectors read the same repository, and the repository's webhook sends the same change again. Without one rule for one event, a single merge shows three times, and every count is three times too high. Without one rule for identity, one person shows as a name in one row and as a login in the next, and a filter on that person misses half of their work.

How it works

  1. A GitHub record names its event. The GitHub webhook and collector 0.5.16 or later state each event's source id: GitHub's own ids and times. A branch name enters only as a digest. A record without an id stays an entry of its own.
  2. One entry for one event. The feed shows the records of one source id as one entry. The webhook's record stands for the event; without a webhook, the first report does. The row says how many sources recorded it.
  3. Every record stays. The audit log keeps each record. The read finds the records of a page's events on any page, so an event shows once and on one page, and the summary counts it once.
  4. Ids stay with their provider. A report that gives another provider's id for its entry is refused.
  5. Stated logins link to people. A collector states an id for each person, with the person's login in the provider. That stated pair links the login to the person, so the provider's own webhook from that login shows the same person, by the newest reported name.
  6. Nothing is matched by name. A member's own linked account and an admin's merge of people come first. A login stated for two people, or only in another provider, links to nobody. Timeline can suggest that two rows are one person; it never merges them by itself.

What the run showed

The replay above is two recorded checks in production on November 14, 2026, each with its own operator test account in a Timeline-only organization, erased afterwards. The checks sent collector-style reports through the public report API, and signed webhook deliveries through a connection with their own secret.

  • The first check sent two collector-style reports of one merge, with two delivery keys and one source id, and a near miss: the merge of another pull request. Then the webhook delivered the same merge.
  • The feed showed the merge once, from the webhook, marked "Same event from 3 sources". The near miss kept its own entry, so the feed held 2 GitHub entries. Pages of 1 and of 2 entries and the summary each counted the merge once, and a report with another provider's id was refused. All 13 checks passed.
  • The entry still showed the webhook's login, carol-q, as an outside agent, although both reports named Carol Q. The release note named this as the next fix.
  • The identity release of the same day linked stated logins to people. 78 minutes after the first check, a second check stated Nia Q with the login nia-q, and Carol Q with carol-q.
  • The webhook's opening of a pull request from nia-q showed as Nia Q. A filter on her or on her login found both her review and her opening, and the summary counted her once, with 2 entries. The merge showed once, with 3 records, as Carol Q. All 9 checks passed.

Limits

  • Test inputs. The checks sent the reports and the webhook deliveries themselves. No real teammates' collectors or real repository sent them, and an outside team has not used it yet.
  • GitHub only. Only GitHub records name their event so far. A Jira move that the webhook and the board sync both record shows twice: the board's tool gives no change id.
  • A person needs a stated login. A person whose collector states no login, for example a board person with only an account id, links through that account id only.
  • The unit in the capture. In the second capture, the two pull requests share one unit only because the test data gave both the same head commit.

Frequently asked questions

Does Timeline delete the extra records?

No. The audit log keeps every record. The feed and the summaries show and count the event once.

Which record does the feed show?

The webhook's record, when there is one, because it comes from the provider itself. Without a webhook, the first report stands for the event. The row says how many sources recorded it.

Can Timeline guess that two names are the same person?

No. Only a stated link connects a login to a person: one that the person, an admin or a collector's report states. A login stated for two people links to nobody, and a suggested merge waits for a person.

  • One identity on every path

    A person's logins across systems resolve to one identity from links that members, admins or collectors state; names are never matched by guess, and merges are suggested, not applied.

  • Timeline collector service

    A separate collector reads GitHub and Jira through a person's own signed-in tools with read calls only. It can preview without sending, sends when the person runs a send or installs the service, and runs as a background service that survives restarts without copies.

    Recorded walkthrough

Turn the numbers into shipped work.

Crewshal runs these choices for you: a persistent AI worker with memory and rules, on your Claude and Codex subscriptions.