Pulse
Resources

FAQ

The questions developers and teams ask most, what to do when something is not working, and the canonical definition of every term Pulse uses.

Updated 10 min readStable

Three things in one place: the questions we are asked most, a troubleshooting guide for when the record is not showing what you expect, and a glossary that defines every term in the product exactly once.

Most questions about Pulse come from one of two places. Either the model is not yet obvious — why can't I log a PUSH, why is my event L1 — in which case the answer is usually a design decision worth understanding. Or something is not being captured, in which case the answer is almost always pulse status.

This page exists so you can stop reading and get back to work. It is deliberately blunt: the answers below state the position rather than softening it, because the surprising parts of Pulse are surprising on purpose.

A recurring theme in these answers is 'no, and it will not be added'. That is not stubbornness. Pulse is a system whose value is entirely derived from the fact that its record cannot be manipulated — the moment events can be edited, PUSHes can be typed by hand, or scores can be set, every other record on the platform becomes worth less. The constraints are the product. They are the reason a Pulse timeline is evidence rather than a claim.

  • What is Pulse? An engineering execution platform. It preserves the record of how software was actually built — the events, decisions, incidents and deployments that code alone never explains.
  • Is it a replacement for GitHub, Jira or a CI system? No, and it is not trying to be. It does not host code, track tickets or run builds. It records the engineering that happens in the tools you already use.
  • Do I have to change how I work? No. Ship as you always have. Execution is captured automatically; the only thing you author is judgment — a BLOCK, an UNLOCK, a PIVOT.
  • Why can't I record a PUSH by hand? Because a hand-written PUSH is a self-report, and self-reports are exactly what Pulse exists to replace. Execution is captured from a source or it is not captured.
  • Can I edit or delete an event? No. The log is append-only. A correction is a new event, and both remain visible — which is the property that makes the whole record trustworthy.
  • Can my employer delete my record or lower my Build Cred? No. Identity is rooted in the developer; organizations attach through a membership edge. No role or permission in Pulse grants that capability, because it does not exist in the model.
  • Does Pulse read my source code? No. It reads execution metadata — that a commit exists, that a pipeline reported a deployment. Never file contents, never diffs.
  • Can I use Pulse for private or company work? Yes, and this is what the Privacy Mask is for: provable but not leaked. Masked events are verified in full and earn in full.
  • Do private events count toward Build Cred? Yes, in full. The engine reads the raw record; masking governs what a viewer sees, not what you earned.
  • How is Build Cred calculated? It is derived from verified events, weighted by trust level, across five dimensions — Delivery, Reliability, Resolution, Architecture, Collaboration. Every point traces back to the event that produced it.
  • Can I raise my Build Cred faster? Only by doing verifiable engineering. There is no write path, no appeal, and volume is not weighted — ten unverified events can be worth less than one proven one.
  • Is the CLI required? Not strictly. BLOCK, UNLOCK and PIVOT can be authored in the Engineering Workspace. Automatic capture and deployment metadata do require it.
  • Is there an API? Not yet. It is designed and reserved. Use the CLI — pulse logs --json returns the same projections the API will serve.
  • What happens if I leave my company? The membership edge closes. Your events, proofs and Build Cred are untouched, because they were never inside the organization to begin with.

Two commands answer most of what you will want to know, and they answer it from the record rather than from memory.

Terminal
bash
# What is Pulse capturing right now, and at what trust level?
pulse status --verbose

# What has actually been recorded?
pulse logs --since 30d

Almost every problem with Pulse is one of three things: the machine is not authenticated, the project is not linked, or the event was recorded somewhere other than where you think. pulse status answers all three, and it is the right first move every time.

Run pulse status. It will tell you which of the following is true, in order of likelihood.

Symptom in pulse statusCauseFix
Identity: not authenticatedThis machine has no credential.Run pulse login. In CI, set PULSE_TOKEN.
Repository: not linkedThe project has no verification source, so nothing is captured from it.Run pulse link github.com/owner/name.
Project: not foundThere is no pulse.json above the current directory.Run pulse init from the repository root.
Events land on the wrong projectA stray pulse.json in a subdirectory is resolving first.Delete it and run pulse config list to confirm what resolves.
Repository linked, still no PUSH eventsThe repository was not selected during onboarding, so Pulse may not read it.Add it in your Pulse repository settings, then re-link.

This is usually correct behavior rather than a fault. Verification is applied at capture time, against the sources available at that moment.

SituationWhyWhat to do
Event is L0It was recorded against a project with no linked repository.Link the repository. Future events attest higher; this one does not change.
A PIVOT is L1Nothing is wrong. No machine can confirm a decision.Nothing. L1 is the correct level for judgment.
A deployment is L1, not L3It was reported from a machine Pulse cannot verify — usually a laptop.Move pulse deploy into the CI pipeline.
Events before the link are still lowProofs are minted once, against the sources present at the time.Nothing. History is not re-graded, on purpose.
Status is pendingThe source has not responded yet.Wait. Pending events are attested when the source confirms; they are not lost.
SymptomCauseFix
pulse login hangs in CIThere is no browser to confirm the code in.Do not run login in CI. Set PULSE_TOKEN in the secret store.
command not found: pulseThe global npm bin directory is not on PATH.Check npm bin -g is on your PATH, or reinstall globally.
Commands run against the wrong projectConfiguration resolves upward from the current directory.Run pulse config list to see what actually resolved.
Duplicate projects with the same nameSeveral people ran pulse init instead of committing one pulse.json.Keep one project, transfer or archive the others, and commit the surviving pulse.json.
A deploy was recorded that then failedpulse deploy ran before the deployment succeeded.Record a corrective event. The original stays — the log is append-only.

Every term Pulse uses, defined once. These names do not change between pages, and there are no synonyms — if a concept has a name here, it has that name everywhere in the product.

TermDefinition
Engineering EventOne immutable record of something that happened. The atom of Pulse. Always exactly one of PUSH, BLOCK, UNLOCK or PIVOT.
PUSHAn execution event — something shipped. Captured automatically from a source; never authored by hand.
BLOCKAn obstruction event — something is broken or blocked, and engineering is on it. Opens a room.
UNLOCKA resolution event — a BLOCK was cleared, and this is what did it. Links to the BLOCK it resolves.
PIVOTA reversal event — a decision or approach was changed, with the reasoning.
TimelineEvents belonging to one entity, ordered by when they occurred. Append-only.
ProjectThe execution container events belong to. Links to a repository. Owns no identity and no reputation.
OrganizationA container that coordinates projects and members. Never owns a developer's identity.
RepositoryThe code host Pulse verifies a project against. A verification source, not a place Pulse stores anything.
VerificationThe trust layer. The process that mints a proof for an event and grades it from L0 to L4.
ProofThe tamper-evident record of a verification: evidence hash, method, source, engine version, timestamp.
Trust levelL0 unverified, L1 self-attested, L2 source-linked, L3 pipeline-verified, L4 independently attested.
Build CredDerived, explainable, trust-weighted reputation across five dimensions. Never self-reported.
DimensionOne of the five components of Build Cred: Delivery, Reliability, Resolution, Architecture, Collaboration.
KnowledgeA durable artifact derived from a resolved incident: problem, solution, lessons, and the events behind them.
RoomThe working space a BLOCK opens. Part of the record, and the raw material a knowledge artifact is distilled from.
Engineering GraphEvery developer, project, organization, event, proof and artifact, connected by typed edges.
ProjectionA derived, rebuildable read model. Every page in Pulse reads one; nothing writes back to the log.
DeploymentA release reaching an environment, reported by the deploying system. Recorded as a verified PUSH.
AuthenticationConfirming you are the engineer behind the work. GitHub in the browser, pulse login on a machine, PULSE_TOKEN in CI.
SharingPointing someone at your record. What they see is decided by visibility and the Privacy Mask, never by the link.
VisibilityWho may see an event: public, organization, private or masked.
Privacy MaskSealing an event's detail per viewer while its proof, position and reputation remain intact. Applied on read, never on write.
CLIThe Pulse command-line interface. The seam between local development and your engineering record.
Canonical terminology.
  1. Something looks wrong. Run pulse status.
  2. It tells you whether the machine is authenticated, the project resolved, and the repository linked.
  3. Fix whichever of the three is not true. That is nearly always the whole problem.
  4. Run pulse logs to confirm the record now says what you expect.

A deployment did not appear. Two commands, start to finish.

Terminal
bash
pulse status

# Project       atlas-gateway (northwind)
# Repository    —                          ✗ not linked
# Identity      @aria                      ✓ authenticated
#
# 0 events captured

pulse link github.com/northwind/atlas-gateway
# ✓ Linked. Verification source: github
  • Run pulse status before asking anyone anything. It is faster and it is more accurate.
  • Learn the trust ladder. Most 'verification is broken' reports are a correct L1 on an event no machine could ever confirm.
  • Use the glossary terms exactly. A shared vocabulary is what makes a record readable by someone who was not there.
  • Read the design answers rather than working around them. The constraints are load-bearing.
  • Waiting for a feature that will not exist — an edit button, a delete, a manual PUSH, a score override.
  • Assuming an event is missing when it was recorded against a different project. Check pulse config list.
  • Treating L1 as a failure. It is the honest level for a decision, and decisions are worth recording.
  • Reading the FAQ instead of pulse status when something is not being captured. The record knows; this page is guessing.
  • Press ⌘K anywhere in the docs to search.
  • Every term in the glossary means the same thing on every page. There are no synonyms in Pulse, on purpose.
  • If a question is not answered here, it is answered in the page for the concept it concerns. Start with Engineering Events; almost everything follows from it.