Composable patterns

Point has a small core: preserve a Session boundary, connect sources through parents, continue from one or several Points, and publish or fetch that history through Git. It does not prescribe one collaboration workflow.

Rich ways of working come from composing these primitives, not from turning Point into a larger platform.

Primitive	What it provides
Stash / Commit	Make a real Session part of immutable history
Parents	Preserve which contexts produced the new work
Resume	Continue, branch, or converge in another Session
Point Branch	Give a current direction a movable, addressable Ref
Push / Fetch	Transport context across people, Agents, and devices through Git

Continue across Sessions and Agents

When a Session pauses, Stash preserves the newly produced worksite. Another Agent continues from the same repository's master:

point stash --session-file session.jsonl
point resume

Resume reads the complete reachable history, while the next Point stores only events produced after that boundary. Continuation does not create another copy of the old Session.

When continuation happens on another device, publish and fetch the same Point Branch first:

# Device A
point push master --remote origin

# Device B
point fetch --remote origin
point resume

Explore in parallel from one worksite

One Point can be the common source of several independent directions:

point resume <origin> --branch bounded-backoff
point resume <origin> --branch circuit-breaker

                         P1 · bounded backoff
                       /
P0 · shared Session
                       \
                         P2 · circuit breaker

Each direction stores only the Session it produces later. P0 remains their shared origin.

Bring several directions into a decision Session

Point does not merge natural language on behalf of people or Agents. A new participant can read several sources, compare evidence, validate alternatives, and make a decision in a real Session:

point resume <point-1> <point-2> --branch master

The next saved Point has several parents. Its parents express provenance; its new Session expresses the judgment that actually happened.

Trace a project change to its worksite

A Git Commit preserves the repository result. A Commit Point preserves the Session that produced it and records the relationship between both histories:

Point lineage ── Commit Point ──→ Git Commit

Git continues to own code, configuration, tests, assets, and other repository facts. Point does not copy them; it lets a later person or Agent return to the context in which they were produced.

Publish the current Git Branch and context together when both are ready:

point push master --remote origin --with-code

Create a context-only Workspace

A Point Space does not have to be a code repository. An empty Git repository can carry shared Sessions:

mkdir context-workspace
cd context-workspace
git init

A team can preserve discussions, resume history, create directions, and publish master without first creating application code or a knowledge platform.

Compose several projects in one Workspace

A Workspace can add code repositories as Git remotes and fetch their published Points:

git remote add frontend ../frontend
git remote add backend ../backend

point fetch --remote frontend
point fetch --remote backend
point resume frontend/master backend/master --branch master

The new Workspace Session continues from several project worksites. Today, the Points it uses become real parents in the Workspace's reachable history. This imports provenance; it is not a live subscription to each remote Branch. When a source project creates a new Point, the Workspace fetches and resumes again.

Develop locally, let a cloud PMO follow

Point does not include project management or reminders. It can provide an observer Agent with continuous, traceable inputs:

Local Session
   ↓ git commit
Local Commit Point
   ↓ point push
Git Remote
   ↓ point fetch
Cloud PMO Agent

Publish locally:

point push master --remote origin --with-code

The cloud PMO fetches periodically, compares remote master with the last Point it processed, and reads only newly reachable nodes. Reminder policy and notification delivery belong to the PMO; Point supplies the original context history and cross-device transport.

A PMO can also follow a context-only Workspace. The Workspace composes several project Points first; the PMO consumes the direction that Workspace currently accepts.

Use one object for local thought and team context

Stash Points and Commit Points share one immutable format:

Working Session
   ├── point stash ── Local Stash Point
   └── git commit  ── Local Commit Point
                              │
                 point push ──┴── Published Point

Pausing, handing off, connecting a project change, and publishing to a team do not require four systems. They are compositions of one context history at different moments.

Point stays small

None of these patterns require Point to become a task platform, document system, Agent Runtime, or centralized collaboration service. Point remains responsible for:

• preserving original Sessions;
• connecting real sources;
• resuming and branching context;
• relating context to Git state;
• sharing it through Git.

PMO systems, Workspaces, parallel experiments, and team workflows can build on those primitives without entering Point's core.