Concepts

Point gives AI Native Development context its own Git-native history.

Point

A Point is an immutable Git Commit whose tree contains:

manifest.json    lineage, source, type, and Git relation
session.jsonl    newly produced participant-visible Session events

session.jsonl preserves the original participant-visible Session event stream in order. Point does not restrict that stream to a closed list of event types, and it does not claim access to hidden model reasoning. It is the source representation; terminal and Markdown output are rendered views.

Session

A Session is the live, ordered working context exposed by an Agent runtime. It is where a Point comes from, not who owns it. Once saved, the same Point can be read by another local Agent, fetched by a teammate, or resumed into several later Sessions.

Each Point stores only the new events since the previous Point boundary. A boundary is the start of the Agent Session, a successful resume, or a successful save. Restored parent events are not copied into the child.

Parents and the DAG

Point lineage is recorded twice when a Point is created:

• as real Git Commit parents, which are authoritative for reachability and transport;
• as a matching parents array in manifest.json, which is easy for agents and tools to inspect.

Point rejects a node when these two representations disagree.

A Point can have several parents:

P1 ──┐
     ├── new Session ── P3
P2 ──┘

This means P3 was created after reading P1 and P2. It does not mean their natural language was automatically merged. The new discussion, verification, and decision are the content of P3.

Point Branch and master

A Point Branch is a movable Git Ref under refs/points/heads/. The default branch, master, identifies the context the project currently accepts.

Point Branches are independent from repository Git Branches:

refs/heads/feature/login          repository direction
refs/points/heads/master         accepted context direction
refs/points/heads/experiment     another context direction

Every Point remains immutable when a Ref moves.

Resume

To resume means to continue from where prior context stopped.

point resume

With no argument, Point resolves master. It walks the complete reachable DAG in oldest-to-newest order, returns every Session once, and records the selected tip as the parent of the next save.

point resume <point-id>

An exact historical ID resumes detached so inspecting history does not move master. Add --branch <name> when the new direction should have a movable Ref.

Resume changes context lineage only. It does not switch a Git Branch, modify the worktree, change an existing Point, or publish data.

Stash, Commit, and Published Points

All Point kinds use the same immutable node format.

State	Created when	Meaning
Working Session	before a save	context is still inside an Agent runtime
Stash Point	point stash	a local checkpoint of newly produced Session events
Commit Point	Agent capture + git commit	the same context node also records the resulting Git Commit ID
Published Point	successful point push	the same immutable Point is reachable through a remote Ref

Push does not create a copy or a new Point.

Git relation

manifest.json records the Git state visible at capture time:

{
  "git": {
    "branch": "feature/login",
    "head": "abc123...",
    "dirty": true,
    "commit": null
  }
}

For a Commit Point, commit contains the resulting Git Commit ID. It is a reference, not a Point parent, so repository history and context history remain independent.