Skill dispatch
Table of Contents
1. Summary
A regulator must select a response matching the disturbance it faces. Dispatch is how this framework performs that selection: given a target, it computes the operations available on it rather than requiring an agent to recall them.
The computation runs in three steps. A target resolves to a type, the type implements one or more regulatory functions, and each function declares operations. The session's System then attenuates what is offered, so the same target presents a smaller surface at the audit level than at S1.
This document states how a target resolves to a type, how verbs register against types, why creation is the case that forces a distinction between a target and an output, and why the table is generated rather than written.
2. Detail
Figure 1: compass-act resolves a target's type, then offers the verbs registered against it.
Actions register against a target's type, never against the command that produced the target. A new source of targets therefore inherits every action for the types it yields, and a new action appears wherever its type does, without anyone editing a table.
Documents carry their type in #+type: frontmatter. Non-document
targets — a branch, a pull request, a worktree, a service, a build
target, a test failure, a database — resolve their kind through compass.
A target whose type cannot be resolved is out of scope for dispatch.
2.1. Creation Verbs
A verb that creates an artefact cannot take that artefact as its target, since nothing can be resolved before it exists. Such verbs are registered against the container's type instead, and the artefact they produce is the action's output rather than its target.
Adding a task is therefore a verb on a story, adding a story a verb on a sprint, and adding a knowledge document a verb on the knowledge index. The dispatcher offers each where the container is resolved, which is also where a person would look for it: holding a story, one asks what may be done with it, and adding a task is among the answers.
Regulatory Functions treats the distinction between a target and an output, and the reason creation forces it.
2.2. The Skills
Three skills implement the model:
compass-act— resolve a target's type, look up the verbs registered against it, filter by the session's level, run the chosen one.compass-act-all— fan one action over a collection.compass-export— hand a result set to the artefact type that owns that payload. Review findings become tasks on a story; backlog candidates become captures; drift findings become tasks. Never invent a new container when an artefact type already exists for the payload.
The verb table is generated from the catalogue, and the requirement is operational rather than a preference. A hand-maintained table drifts within a sprint, and a pairing that cannot be reproduced by automated means is one the framework does not hold: if the table cannot be generated, the dispatcher is not built.
compass-agile-find-heading and compass-act answer different questions.
Heading picks which work to do; act picks which verb applies to this
noun.
2.3. Inventory
Target type against verb, with the source each type resolves from. Not yet written: it is generated from the verb table, which arrives with the dispatcher. Until then the types and their operations are in Regulatory Functions.
3. See also
- The Cybernetic Skills Framework — why a regulator computes its response.
- Skill architecture — the index into the cluster this page belongs to.
- Regulatory Functions — the functions a type implements, which declare the operations dispatch offers.
- Systems and levels — the attenuator that decides which of those are shown.