Version control for AI Native context.
Make Sessions evolve like code—with history, branches, parents, and a shared master.
Website · 中文 · Install · Quickstart · MIT
AI Native Development does not happen in the repository alone.
Intent, exploration, evidence, actions, corrections, and decisions unfold in a Session. Their original order is the live context in which the work is created. Point preserves that Session without reducing it to a document or a summary.
Git versions the repository. Point versions the context.
AI Native projects have two histories:
| Repository history | Context history | |
|---|---|---|
| Working state | Worktree | Session |
| Immutable version | Commit | Point |
| Current direction | Git Branch | Point Branch |
| Default direction | main or master |
master |
| Lineage | Commit parents | Point parents |
| Continue from history | Checkout | Resume |
| Team transport | Push / Fetch | Push / Fetch |
The histories remain independent and connect where the work connects. A Point records the Git state visible when it was created. A Commit Point links a context lineage to a Git Commit.
flowchart LR
S0["Session<br/>live working context"] --> P0["Point P0"]
P0 --> P1["Point P1"]
P1 --> P2["Point P2"]
M["Point master"] --> P2
P0 -.-> C0["Git commit"]
P2 -.-> C2["Git commit"]
Point enters the development flow at two different moments:
Working Session
│
├── save a continuation boundary ── point stash ── Local Stash Point ──┐
│ ├── point push ── Published Point
└── record a project change ───────── git commit ─── Local Commit Point ┘
Stash creates a continuation boundary before the work is committed. It preserves the newly produced Session events locally so another Agent can read them, continue from them, or open another direction. It is independent of git commit.
Commit anchors a Session boundary to a project change. When normal git commit records a repository change, Point creates a Commit Point that links the newly produced Session events to that Git Commit.
Both use the same immutable Point format. Both remain local until Push, and either can be published directly. Publishing changes reachability, not identity: the Point does not become a different object when the team receives it.
Every Point is immutable. The default Point Branch, master, is a movable Git Ref that identifies the latest accepted context.
When an idea changes, Point does not edit the old Session. A new Session records the correction, produces a new Point, and advances master:
P0 · original intent
└── P1 · first direction
└── P2 · corrected context ← master
Normal work resumes from master. Historical Point IDs remain available when a human or agent needs to reconstruct why an earlier project change happened.
Point master is independent from the repository's Git Branch. It lives under refs/points/heads/master and can link to any Git Branch, Commit, or worktree state.
A new Point stores every participant-visible event that happened after the previous Point boundary. It does not copy its parents' transcripts into itself.
Point C
├── manifest.json parents · source · Git relation
├── session.jsonl newly produced Session events only
└── Git parents
├── Point A
└── Point B
The history remains complete because A and B are immutable and reachable by reference. point resume traverses the parent graph and returns every reachable Session once—even when several branches share the same ancestor.
This separates three concerns:
- Complete Session. Preserve the original, participant-visible event stream exposed by the Session adapter, in order.
- Complete lineage. Keep every source reachable through immutable parent references.
- No duplicated history. A child stores only the events that happened after Resume; parent Sessions remain references.
Point does not claim access to hidden model reasoning.
Resume the same Point into two branches to explore independently:
P1 · queue direction
/
P0 · shared source
\
P2 · stream direction
Then begin a new Session from both results. The discussion, verification, and decision that actually happen next become P3:
P1 ──┐
├── new Session ── P3 ← master
P2 ──┘
Point never combines natural language automatically. A multi-parent Point records that a new real Session continued from several sources.
This direction is no longer specific to one Agent:
- OpenAI Codex organizes agent work into separate project Threads, keeps context while switching between parallel tasks, and carries Session history across the App, CLI, and IDE extension.
- GitHub Copilot exposes Agent Sessions and logs, links Git Commits back to those logs, and supports sharing and querying past Sessions.
- Gemini CLI checkpoints the Git state, complete conversation history, and Tool call together; its Session workflow supports Resume, Rewind, and Fork.
- VS Code treats local, background, and cloud agents as independent Sessions with their own conversation history and Tool results, and lets several run in parallel.
- Claude Code persists project Sessions and supports Resume and Branch/Fork while retaining the original Session.
The implementations differ, but the direction is consistent: Session is becoming a durable, addressable, continuable development unit. Point takes the next step by making that history project-owned, cross-agent, cross-team, and Git-native.
Install the Point Skill and ask for the outcome:
Stash this unfinished Session as a Point.
Resume the project context.
Start a new direction from this Point.
Continue from both Points on master.
Commit this result with its Session.
Publish master to the team.
The Skill supplies the participant-visible Session and handles branch and Session tokens. Point data remains readable through Git and does not depend on the agent that created it.
Requires Git and Python 3.9 or newer.
python3 -m pip install "git+https://github.com/guix4ever/point.git"npx skills add guix4ever/point --skill pointAdd -g to use the Skill across projects:
npx skills add guix4ever/point --skill point -gpoint stash --session-file session.jsonlThis creates a Local Stash Point independently of git commit. session.jsonl preserves the original participant-visible event stream in order. Agent integrations create it automatically. The first save creates master; later saves store only new events, use the current tip as a parent, and advance the Ref.
point resumeWith no ID, Resume reads master. It reconstructs the reachable Session lineage from oldest to newest, loading every Point once. The next saved Point continues that branch without copying the restored events.
point resume <point-id> --branch experimentSaving the new Session creates or advances experiment. Resuming an exact historical ID without --branch stays detached and does not move master.
List Point Branches:
point branchpoint resume <point-a> <point-b> --branch master
point stash --session-file decision-session.jsonlThe saved Point has both Points as parents and becomes the new master tip.
Install the optional repository Hook once:
point hooks installBefore an Agent runs git commit, the Point Skill prepares the new visible Session events. The normal post-commit Hook then creates a Commit Point linked to the resulting Git Commit. If no real Session was prepared, the Hook creates nothing—Point never substitutes placeholder text for the worksite.
point push masterPoint publishes master, its tip, and every required parent. Another clone can run:
point fetch
point resumeUnrelated local Points and branches remain local.
Session is the first durable unit because it preserves the complete worksite. The next layer is finer-grained intent:
- reference an exact expression, response, result, or decision inside a Session;
- connect one intent to the project changes it influenced;
- mark a later intent as a correction or continuation without changing its source;
- let agents load the smallest useful context while the complete Session remains reachable.
Point starts with Session history. Its direction is an intent graph grounded in that history.
- AI Native Development
- Get started
- Collaboration workflows
- Concepts
- CLI reference
- Agent Skill
- Git integration
- 中文使用指南
python3 -m unittest discover -s tests -v