Design defines what PAC is made of. This defines the words you meet
reading the code and the repositories, which are not the same list: some are
concepts, and some are just what a thing is called around here.
The system
word
what it names
node
one running instance of PAC, acting for a single principal. Two processes: pac-daemon and pac-worker
principal
whoever a node acts for -- a person, a group, a company, another agent
peer
another node, as seen from this one
constellation
the six repositories that make up PAC's source, laid out as siblings under one directory and finding each other by relative path
spine
the eight core plugins every node runs, one row each in spine.yml. What a node is, as opposed to what it was given
seam
one core plugin's contract and the port an adapter plugs into. A new group of adapters is a new seam
flow
an installable program that runs a multi-step interaction with peers. The applications
flow service
shared machinery flows call rather than speak on the wire: negotiation, records, results, artifacts, intake
adapter
one outside system bound to one seam -- a transport, a source, an operation, an executor, a package source
What a node holds and does
word
what it names
source
one named thing a principal holds, kept current by the adapter that owns it. A flow can name one but never read it
stake
to put a named source into a computation without holding it. The owning plugin does the putting; the flow only names
descriptor
what a node tells a peer it holds: per source a name, a sentence, what is inside, what it needs, and where using it discloses. Never the contents
offering
the union of what this node's installed sources say they offer -- what a descriptor is built from
board
a list of what the network is offering, as a node reads it: a skills board, a query board. Its rows come from a directory, so they are text of unknown origin
run
one conversation with a model: turns in order, opened by a flow and closed by it
turn
one exchange in a run. The kernel composes nothing and reads nothing -- what a turn means is the flow's
intake
the flow service that reads a principal's sentence, decides which declared intent it names, and starts that flow on its own route
intent
two different things, by context: what a principal wants done, and the declaration a flow makes to intake saying what it is for and how to start it
Negotiating, and carrying it out
word
what it names
artifact
a versioned resource two nodes negotiate over. Each change is a revision, signed by its author
round
one pass of a negotiation: open a workspace, ask a model, commit what it wrote, send it. The other side's round answers it
head
the revision this side last saw. An agreement over a head a node does not hold ends the task
redraft
a failed check handed back to the same run, inside the same turn budget, rather than starting a new round
half
one of the two things meta negotiates in sequence: the design, then the program
drive
a flow service that advances a durable state machine one step at a time, so a restart resumes where the records say it was
landmark
a step of a box run each side tells the other about: a party key, the session, giving up
the box
the joint-computation runtime (jc-tee-vm): attested, runs a program every party approved, once, over inputs only it decrypts
egress
the hosts a box program may reach, declared in the design and bound into every party's approval signature
sweep
a background pass on an interval that gives up on work nothing has advanced
Working on it
word
what it names
lane
a repository's dev environment: a directory, two whole nodes, the plugins under whichever flow is being tried, and the panes to watch it in. just dev
gate
what has to pass before a commit: pnpm check -- format, lint, manifest drift, types, build, tests
devkit
@projectpac/flow-devkit: the lane tooling every flow repository shares, including the lane itself
the fixtures
the sample corpus the lanes seed two agents from, kept once in the devkit