Commission — Positioning

Status: canonical. Owned by relay-54. Every other surface — the website, the documentation, README.md, commission --help, launch posts, pricing pages — quotes this document rather than reinventing its own wording. If a surface needs to say something this document does not say, change this document first.

This is a reference, not a pitch deck. Its job is to make it impossible for five surfaces to say five different things.

Rules for anyone quoting it

The sentences marked canonical are copied verbatim, not paraphrased.
Vocabulary entries in §6 are the only definitions of those words. A surface that needs a different meaning is wrong, or needs a different word.
Nothing in §8 marked planned may be described anywhere as shipped until its task is done. Check with commission show <id> before writing a claim into a page.

1. The pitch, in three sizes

1.1 One sentence (canonical)

Commission turns goals into verified software by coordinating the task graph, execution environment, and shared context of humans and AI agents.

Shorter forms, when the sentence will not fit — use one of these exactly, never a new improvisation:

Tagline (canonical): The execution layer for software delivery.
Half-sentence (canonical): Agents operate it; humans are asked only for judgment.

1.2 One paragraph (canonical)

Commission is the execution layer for software delivery. It holds the task graph, the rules for who may work on what, and the context each piece of work needs — and it hands them to whoever is doing the work, human or agent, in one read. Work is claimed atomically, so many agents can run in parallel without collisions. Completion is a predicate, not a status field: done is refused until acceptance criteria are ticked and the evidence a task’s gate requires is attached, and the refusal names the exact command that fixes it. Everything is derived from one truth — boards, “what’s ready”, standup, and blocked state are queries, so drift is structurally impossible. Commission does not write your code and does not replace your judgment; it is the layer everything else runs on.

1.3 One page (canonical)

Commission turns goals into verified software by coordinating the task graph, execution environment, and shared context of humans and AI agents.

Software delivery now has a new kind of worker in it. Agents can write real code, and the constraint has moved: not can it be built, but can anyone tell what is true. A tracker built for humans assumes a person is holding the plan in their head between standups. That assumption breaks the moment five sessions are running at once, none of them remembers yesterday, and “done” is a column somebody dragged a card into.

Commission is the layer where that coordination lives. It is not a coding agent and not another tracker; it sits between intent and execution, and it is operated by machines.

One truth, derived views. Status lives in exactly one row. Boards, the ready frontier, standup narratives, and blocked state are queries over it. There is no second place to update, so there is nothing to keep in sync.

Work is dispatched, not assigned. commission next --claim picks the highest-value workable task and claims it in a single transaction. Claims are leases, so a crashed session never wedges a task, and N agents running the same command each get a different one.

Context arrives in one read. A claim returns a context bundle: the task body, acceptance criteria, dependency state with satisfaction, parent and children, linked documents, attached evidence, prior session notes, recent events, and the exact commands that finish the task from its current state. A cold session becomes a productive one in a single command.

Completion is verified, not asserted. A task’s gate names the evidence kinds it requires — a PR, a test run, a benchmark, a rollback plan. commission done refuses until they exist and until every acceptance criterion is ticked, and the refusal says what is missing and the exact command that supplies it. Refusals are prompts, not errors.

Parallel by default. The ready frontier is everything workable right now: dependencies satisfied, children closed. It is claimable by many actors at once, and tasks that declare the files they touch are batched so overlapping work is visible before it collides.

Humans stay where judgment is. Every action is attributed to an actor. Every automatic action explains why. Humans own intent, approval, and the calls an agent should not make alone; Commission owns everything in between.

Adoption is incremental. Commission is at its best as the source of truth, but a team can keep Jira, GitHub, and CI and still benefit: import an existing backlog, or bind a subset of tasks to the issues and pull requests they really are. Nothing external is ever written unattended.

Commission does not run your build, spawn your agents, or write your code. It is the substrate they run on — the place where what is true about the work is kept.

2. The category: an execution layer

Commission is an execution layer: the layer between intent and execution that holds what is true about the work, decides what happens next, and refuses to call anything finished until it is verified.

A layer is defined by what sits on each side of it:

above Commission	Commission	below Commission
goals, intent, judgment, approval — humans, and the roadmap wherever it lives	the task graph, dispatch, claims, context, gates, evidence, the event log	the actors who do the work — coding agents, humans, CI, the repository, the environment

The test for whether something belongs in this category is simple: can a machine operate the whole loop? Not read from it, not receive a webhook from it — operate it. Plan, claim, work, record, prove, close, and pick up the next thing, with a human touched only where judgment is genuinely required. A tool whose primitives assume a person is looking at a screen is not an execution layer, no matter how many integrations it has.

Three things Commission is deliberately not the category of:

Not AI project management. “AI project management” means a tracker with a model bolted on: summaries, auto-generated tickets, sprint predictions. The tracker’s model is unchanged; the AI is a feature inside a human workflow. Commission changes the model — the primitives (atomic claims, derived readiness, evidence gates, context bundles) exist because machines operate them.
Not another Jira. Commission does not want to be the system of record for the organization: no portfolio reporting, no capacity planning, no workflow designer, no permission matrix. It is the system of record for execution.
Not another coding agent. Commission contains no model, performs no inference, and writes no code. It is agent-neutral by construction: Claude Code, Codex, Cursor, a script, or a human at a terminal all speak the same commands.

Why “layer” and not “tool”

Because the value is compositional. A tool you adopt instead of something; a layer you put underneath everything and the things above it get better. Commission’s adoption story is additive — keep your editor, your agent, your CI, your Jira — which only makes sense if the category is a layer.

3. The three contrasts, argued

These are the three sentences the whole positioning rests on. Asserting them is worthless; each has to survive being argued.

3.1 Unlike Jira, Commission understands software

Jira’s data model is a ticket: a title, free text, a status name, and custom fields. It is domain-agnostic by design — the same model runs a marketing campaign and a kernel port. That generality is exactly what it cannot afford here.

Concretely, a general ticket model cannot compute the three things that matter to a machine doing software work:

What is workable right now. In Jira, a “Blocks” link is a report — a thing a human reads. Nothing recomputes an issue’s workability when the blocker closes. In Commission, blocked is derived: a task is ready when its dependencies are satisfied and its children are closed, evaluated at query time. There is no blocked status to set, and therefore none to forget to unset.
What “done” requires. Jira can force a field to be non-empty before a transition. It cannot know the field is true. Commission’s gates name evidence kinds (pr, test, commit, benchmark, docs, rollback), the evidence is attached as data with a reference, and done is refused until it is there. The refusal names the missing kinds and the exact command.
Where the work happens. Repositories, pull requests, branches, and the files a task touches are first-class in Commission: a task declares the paths it touches so parallel work can be batched without collisions, and it can be bound to the pull requests it actually is. In Jira these arrive as third-party links, decorations on a ticket that the model does not understand.

Fair credit. Jira is genuinely excellent at things Commission declines: cross-team process, org-wide permissions, audit for non-engineering functions, and the portfolio-level reporting a VP needs. “Commission understands software” is not “Commission is better than Jira” — it is “Commission’s model is about software delivery, and Jira’s is about work in general.” Teams keep both; see §7 and docs/interop.md.

3.2 Unlike coding agents, Commission remembers

A coding agent’s memory is its context window plus whatever it is told to re-read. Between sessions, three things are routinely lost:

Why something was rejected. The approach that was tried and abandoned lives in a transcript nobody opens. The next session tries it again.
What state the work was in. “Mostly done, pending the migration” is knowledge that exists only in whoever ran the last session.
What the acceptance conditions were. They were in the prompt, and the prompt is gone.

Commission makes the durable parts data: append-only events, session notes attached to the task, acceptance criteria with their tick state, evidence with references, and — in the model, per-task — the answers to escalated decisions . At claim time they all come back as one bundle, alongside the dependency graph and the linked docs. The next session starts where the last one stopped, in one command, without a human reconstructing the story.

Fair credit and honest limits. Commission is not a semantic memory system. There is no embedding store and no inference; recall is full-text search plus graph traversal over what actors actually wrote down. Its advantage is not magic — it is that the workflow makes writing things down the path of least resistance, and that what is written is attached to the task rather than to a session that ends. If nobody leaves notes, Commission remembers exactly the structured facts: transitions, claims, criteria, evidence, and who did what when. That is already more than a transcript.

3.3 Unlike project management tools, Commission can execute

The precise claim: in a project management tool, a state change is a record of work that already happened, typed in afterwards by a person. In Commission, the state change is the operation.

commission next --claim is dispatch. It selects by the project’s declared policy (severity, sprint, due date, priority, rank, age), then takes an exclusive lease in a single SQLite transaction. Two agents running it concurrently get two different tasks. In a PM tool, assignment is a human affordance with no concurrency semantics — two agents will happily pick the same ticket.
commission claim is a lock with an expiry. Claims are leases, so a crashed agent releases the work by not existing; a live one extends it. “Assignee” in a tracker is a label with none of these properties.
commission done is a predicate. It evaluates open children, unchecked criteria, and missing gate evidence, and returns a refusal listing what is missing plus the command that fixes it. In a PM tool, “done” is a column you drag a card into: it cannot fail, so it carries no information.
Every one of these is a machine interface first — CLI with --json, an MCP server, and an HTTP API over the same core — with the human web view as the read-only derivative, not the other way round.

RC1 extends this into the environment: commission workspace prepare will materialize the place the work happens — worktree, environment variables from a provider chain, allocated ports, setup steps — so that a task and the environment it runs in are one object .

The honest boundary. “Execute” does not mean Commission writes code, runs your test suite, or spawns agents. It never does any of those. It means the delivery loop can be driven through Commission by a machine, and that the loop’s checkpoints are enforced rather than reported. Anything that runs is run by the actor; Commission is what makes the running safe, attributable, and verified.

4. The objections, answered

A positioning document that cannot survive its own strongest counter-argument is useless. These are the real ones.

4.1 “Linear plus Claude Code already does this.”

This is the strongest objection, and for one human with one agent it is close to correct. A disciplined engineer with Linear, a good CLAUDE.md, and an MCP connection gets most of the value, and should not switch on the strength of a paragraph.

The objection breaks in three specific places:

Concurrency. Linear’s assignee field has no atomic-claim semantics and no lease. With two or more agents working the same backlog, nothing prevents both from picking the same issue, and nothing recovers an issue held by a session that died. Commission’s claim is a conditional UPDATE inside a transaction with an expiry — that is not a feature you can add with prompting.
Verified completion. In Linear, an agent that believes it finished moves the ticket to Done, and the ticket is now Done. There is no mechanism by which the system can disagree. Commission’s done is refusable, and the refusal is a prompt the agent can act on. The difference is whether “done” is a claim or a checked fact — and if you are letting agents close work, that is the whole question.
Cold-start cost. Resuming with Linear + an agent means the human reassembles context: which issue, what was decided, which files, what is blocked on what. Commission’s bundle is one call, and it includes the reasoning from prior sessions because prior sessions were made to write it down.

Where the objection stands. If you have one agent, review every diff yourself, and rarely resume work across sessions, Commission’s marginal value is thin and you should say so rather than argue. The curve turns sharply at: more than one agent at a time, work that spans sessions or days, or the moment you want an agent’s “done” to mean something without you reading everything.

4.2 “So it’s a workflow engine with extra steps.”

Workflow engines model transitions; Commission models permission to act and proof of completion. A workflow engine will happily let you configure a transition to done; it has no opinion about whether the work happened. Commission’s gates are data attached to the task, evaluated at the moment of closing, and the failure path is a message written for a machine to act on. Also, a workflow engine is configured by an admin for humans to follow. Commission’s rules are declared in a file in the repository, next to the code, and are read by the things doing the work.

4.3 “Agents will get good enough that none of this is needed.”

The better agents get, the more of them run at once, and the more of the work no human read line by line. Both of those increase — not decrease — the need for atomic dispatch, attribution, durable context, and evidence-backed completion. Capability raises the value of coordination; it does not substitute for it.

4.4 “This is just a to-do list with SQLite.”

Correct about the implementation, wrong about the interesting part. The interesting parts are the invariants: readiness is derived rather than stored, so it cannot be stale; claiming is atomic, so parallelism is safe; done is refusable, so completion is meaningful; state changes are append-only, so history cannot be rewritten. The storage engine is the boring, deliberate part — one file, no server, WAL, exportable.

4.5 “We already have too many tools.”

Commission’s honest answer is that it is subtractive where it lands: it replaces status documents, “current state” markdown, and the second board someone keeps in a spreadsheet — not your editor, agent, CI, or Jira. If it adds a tool without removing one, it has been adopted wrongly.

4.6 “We can’t put our backlog in yet another system.”

You do not have to. Import an existing backlog and stop, or bind only the subset of work that genuinely must reflect outward. No import and no bindings means none of the interop machinery is active at all, and Commission never writes to an external system unattended. See docs/interop.md, including its honest caveat that every Jira instance needs a configuration pass.

4.7 “Won’t agents just `--force` past the gates?”

They can — and the override is recorded, requires a stated reason, and appears in the event log and the standup. Commission’s position is that a system which cannot be overridden gets worked around invisibly; one that makes overrides expensive and legible gets overridden rarely and traceably. The project instruction to agents is explicit: do not --force unless a human asked.

5. Audiences

Four audiences. For each, the one sentence they should believe after reading. These sentences are what the corresponding website section, docs guide, and pitch have to produce — they are the target, not necessarily the copy.

5.1 Solo founder

“I can run five agents on my product and still know, at any moment, exactly what is true.”

What they feel: leverage without losing the thread. They are the bottleneck on everything, and the failure mode is not a missed sprint — it is losing a day re-deriving what an agent did yesterday, or shipping something they thought was finished. Emphasize: one command to resume, nothing to keep in sync, no ceremony, no process to administer, two-key config. Do not emphasize: approvals, roles, org policy, reporting.

5.2 Startup engineering team

“We get the parts of process that prevent disasters, and none of the parts that slow us down.”

What they feel: they deliberately rejected heavyweight process, and they are now watching agent-assisted work outrun their ability to review it. Emphasize: parallel work without collisions, evidence-backed completion so review is targeted, standup and board as queries rather than meetings, no estimation and no story points. Do not emphasize: migration tooling, compliance, portfolio views.

5.3 Enterprise engineering organization

“We can let agents do real work inside our existing systems without giving up control or auditability.”

What they feel: the mandate to adopt AI, and no defensible answer to “who did this, under what authority, and how do we know it was verified.” Emphasize: every action attributed to an actor, append-only history, evidence required at completion, human approval as data that an agent cannot satisfy , allowlisted integrations so a project cannot write to another project’s systems, and Jira/GitHub/CI kept in place. Do not emphasize: “replace your tracker.” That is not the sale, and it is not true.

5.4 Hybrid human/AI team

“Humans and agents work the same graph under the same rules, and the handoff between them is a data structure rather than a Slack message.”

What they feel: the seam. Work crosses between people and agents several times a day, and every crossing loses context or duplicates effort. Emphasize: one graph with one set of rules for both kinds of actor, execution policy that routes what only a human should do , the inbox as the human counterpart to next , escalation instead of guessing, and a context bundle that both kinds of actor read. Do not emphasize: autonomy for its own sake. The pitch is a clean seam, not fewer humans.

6. Vocabulary

These definitions do not vary. The CLI’s help text, the docs, the website, and the API reference all use these words with exactly these meanings, and use no synonym for them. “Status” in the table below is the state of the implementation as of RC1 planning; the definition is canonical either way.

term	definition	status
task	The single recursive unit of work: it may have a parent, children, dependencies, acceptance criteria, evidence, and a gate. There is no epic/story/subtask taxonomy — a task is a task at every level.	shipped
task graph	The set of tasks in a project plus the parent/child and dependency edges between them. It is the plan; everything else about the plan is a query over it.	shipped
ready frontier	Every task that is workable right now: open, all dependencies satisfied, all children closed. Derived at query time and ordered by the project’s selection policy, never stored.	shipped
blocked	A derived condition, not a status: a task is blocked when it has at least one unsatisfied dependency. It cannot be set or cleared by hand.	shipped
claim / lease	A claim is exclusive permission to work a task, taken atomically so concurrent actors never collide. Every claim is a lease with an expiry, so an abandoned task becomes reclaimable instead of stuck.	shipped
actor	The identity acting on a task, human or agent, recorded on every event and claim. Humans own judgment; agents own execution.	shipped, including the declared registry with roles, capabilities, and autonomy ceilings (relay-33)
gate	A named list of evidence kinds a task must have before it can be completed, declared per project as data — not a process document.	shipped
evidence	A recorded, referenceable fact that a required condition is met — a pull request, a test run, a commit, a benchmark, a document. Evidence is attached to the task; `done` is refused until the gate’s kinds are present.	shipped
acceptance criterion	One checkable statement of what must be true for a task to be complete, ticked individually. Unticked criteria refuse completion.	shipped
refusal	A rejected action that states what is missing and the exact command that fixes it, and exits with code 2. Refusals are prompts, not errors.	shipped
context bundle	Everything needed to work a task, returned in one read: body, acceptance criteria, dependency state, parent and children, linked documents, evidence, prior notes, recent events, and the commands that finish it from here.	shipped, including an explicit token budget with declared omissions (relay-28)
note	A durable breadcrumb an actor leaves on a task — a decision, a dead end, a discovery — written for the next session rather than for a reader today.	shipped
event log	The append-only record of everything that happened, per project and per task, read forward with a cursor. History is added to, never rewritten.	shipped
touches	The file paths or globs a task is expected to modify, declared so that overlapping tasks can be batched apart before parallel work collides. An overlap warning is advisory, not a lock.	shipped
divergence	A disagreement between Commission and a bound external system about the same fact, surfaced with one command that resolves it. Observable signals (pull request state) beat asserted claims (a status field).	shipped
binding	The declaration that a task is a specific external object — a Jira issue, a pull request. Bindings are the only thing that activates any interop machinery.	shipped
execution policy	The rules on a task or project for who may execute it: preferred actor, autonomy (`autonomous`, `supervised`, `human_only`), and the roles or capabilities required to claim it.	shipped and enforced, in the claim path and the ready frontier (relay-34)
approval	A recorded human judgment that work is acceptable, stored separately from technical completion and never satisfiable by an agent. A verification is its sibling: a human confirming something is actually true.	shipped; `--force` cannot override it (relay-35)
workspace	The prepared place a task’s work happens — checkout or worktree, environment variables, allocated ports, setup and teardown steps — described by a provider-neutral interface and returned as a JSON descriptor.	shipped, with six environment providers including GitEnv (relay-39 through relay-42)
context fingerprint	A stable hash over the project’s tracked guidance files, recorded when a task is claimed, so any session knows which version of the rules it was operating under.	shipped, and machine-stable across checkouts (relay-37)
drift	The condition where tracked guidance changed after a task was claimed, meaning in-flight work is running against stale rules.	shipped; it warns and never refuses (relay-38)
inbox	The human counterpart to `next`: a fully derived queue of everything waiting on a person’s judgment — approvals, escalated questions, divergences, stale claims — each item stating why it needs them, what happens if ignored, and the one command that acts on it.	shipped, and it is what the landing page is built around (relay-43)
ask / answer	An agent escalating a judgment call instead of guessing, and the human decision that resolves it — recorded permanently in the task’s context.	shipped; only a human may answer, and `--blocking` genuinely stops agents (relay-44)

Terms with a fixed relationship

A project contains tasks; a task id is <project-slug>-<n> and never changes.
next serves actors of kind agent; inbox serves actors of kind human. Both are derived from the same graph.
Gate is the requirement; evidence is the satisfaction. Never use one for the other.
Claim is exclusivity; execution policy is eligibility. A task can be eligible and unclaimed, or claimed and ineligible for anyone else.

7. Anti-positioning

7.1 What Commission is not

Not a coding agent. No model, no inference, no code generation. Commission never writes, edits, or reviews source.
Not an agent runtime or scheduler. It does not spawn processes, supervise sessions, or manage model calls. You fan out agents; Commission makes fan-out safe, attributable, and collision-visible.
Not a CI system. Commission records that a test run happened and where to find it. It never runs one.
Not a replacement for Jira at the organization level. No portfolio management, capacity planning, workflow designer, or org-wide permission model.
Not AI project management. No generated summaries substituting for facts, no predicted delivery dates, no AI-written tickets nobody asked for.
Not a chat or collaboration tool. Notes are breadcrumbs for the next session, not a discussion thread; there is no @-mention culture to maintain.
Not a knowledge base. Commission links to your documents; it does not own or host them.
Not a store of personal preferences. Commission versions the project’s committed guidance, never an individual’s private settings.
Not a metrics or estimation product. No story points, no velocity, no burndown, no forecast.
Not a hosted SaaS you must sign up for. Commission is a binary and a SQLite file. (Distribution, pricing, and licensing are open decisions — relay-52, relay-56, relay-57 — so claim nothing more specific than this until they land.)

7.2 What Commission deliberately declines to do

Each of these is a decision, not a gap. If a request lands in this list, the answer is “no, and here is why”, not “not yet”.

Estimation. Story points and human-guessed durations are the least reliable field in any tracker, and their main use is comparing teams. Commission has neither.
A settable blocked status. Blocked is derived from dependencies. A status that can be set can be wrong, and a wrong blocked status is worse than none.
A status taxonomy. Five statuses, moved only through transitions with explicit rules. No configurable workflow designer — the configurability that makes Jira universal is exactly what makes it uncomputable.
Freeform status writes. Nothing can write a status except a transition, so every state change is validated and logged.
Silent automation. Commission never pushes to an external system unattended, never auto-reopens a done task, and never auto-cancels work. Every automatic action explains itself.
Two-way sync as a way of life. Interop is an adoption bridge — import and stop, or bind a deliberate subset. It is not part of the daily loop, and the docs say so plainly.
Agent-satisfiable human approval. When approvals ship, an agent attempting to record a human approval is a refusal, not a warning. The whole value of the requirement is that it cannot be automated away.
Inference about intent. Configuration is deterministic: a strict schema, unknown keys refused rather than ignored, an explicit precedence chain, and config explain to say which layer set what. Commission does not guess.
Being the interface humans work in. The web view is read-only by design. Humans observe and judge; they do not drive the loop by clicking.

8. Shipped versus planned

Positioning that describes unbuilt software is marketing. This is the ledger every other surface checks before making a claim. Verify with commission show <id> — an item below is only safe to describe as shipped once its task is done.

Shipped today

Task graph with recursive tasks, parents, and dependencies · derived ready frontier with per-project selection policy · atomic lease-based claims with reclaim on expiry · five statuses with validated transitions · acceptance criteria · evidence gates enforced at done · refusals carrying what-is-missing and the fixing command · context bundles · notes · append-only event log with cursor · full-text search · board, standup, and export as derived views · atomic graph creation via apply · strict versioned .commission.json configuration with precedence and provenance · CLI, HTTP API, MCP server, and read-only web view over one core · Jira and markdown import, Jira/GitHub bindings, divergence detection, and supervised sync.

Planned for RC1

Packaged distribution — install script, Homebrew tap, npm, GitHub Releases — and container images (relay-51–relay-53). All three wait on one green CI run; the pipeline is built and verified locally, and windows-x64 has never been executed on a Windows machine.

Nothing else on this page is future tense. If you are adding to this list, check the binary first: this section has been wrong in the optimistic direction once and in the pessimistic direction three times, and the second is the one that makes a true product sound unfinished.

Shipped since this document was first written

Actor registry with roles and capabilities (relay-33) · execution policy and autonomy — preferred actor, mayExecute, eligibility filtering ahead of ordering (relay-34) · approvals and verifications as data, which --force cannot override (relay-35) · explainable routing and derived delegation suggestions (relay-36) · context tracking with machine-stable fingerprints (relay-37) · drift detection that warns and never refuses (relay-38) · provider-neutral workspaces, worktrees, deterministic port allocation, hooks, and six environment providers including GitEnv (relay-39–relay-42) · commission inbox (relay-43) · ask/answer escalation, where a blocking question genuinely stops agents (relay-44) · human surfaces in the web view, including the first mutations it has ever offered (relay-45) · context bundle token budgets with declared omissions (relay-28) · optimistic concurrency for edits (relay-29) · migration harness, upgrade validation, and pre-migration backup (relay-50).

Deliberately undecided

Pricing and metering (relay-56) and hosting (relay-6; answered — after the RC1 cut). Licensing is decided: Commission is proprietary and the repository is private (see docs/licensing.md). Until pricing lands, no surface states a price or a hosted offering.

9. Language rules

Consistency across surfaces is mostly a matter of never introducing a synonym.

use	not	why
task	ticket, issue, card, story, epic	Commission has one recursive entity; the others import a taxonomy Commission rejects.
actor	user, assignee, agent name	Humans and agents are the same kind of thing in the model.
claim	assign, lock, take	Assignment is a label; a claim is an atomic lease.
ready frontier	backlog, queue, sprint	The frontier is derived and parallel; a backlog is a list.
gate / evidence	definition of done, checklist	Gates are data checked by the system, not an agreement people remember.
refusal	error, failure	Exit code 2 is an actionable prompt, and the wording matters.
context bundle	context, prompt, payload	It is a specific structure with named contents.
execution layer	task tracker, project management tool, orchestrator	The category claim; see §2.
verified software	quality, confidence	Verification here means evidence attached, not a feeling.

Phrases to avoid entirely: AI-powered project management, autonomous software engineer, replaces your engineering team, 10x productivity, self-driving delivery, AI teammate. They all promise something Commission does not do and cannot verify.

Tone: declarative, specific, and willing to state limits. Commission’s own refusals are written this way, and the product’s voice should match its error messages.

10. Surface reconciliation

Every surface derives from §1. These are the reconciled strings.

10.1 `commission --help` (top-level description)

Current (src/cli/index.ts): “LLM-first task tracker: agents operate, humans observe. Exit codes: 0 ok, 1 error, 2 refusal, 3 not found.”

The conflict is “task tracker”: §2 states plainly that Commission is not a tracker, and the CLI’s first line is the highest-traffic sentence in the product. Recommended:

the execution layer for software delivery — agents operate it, humans are asked only
for judgment. Exit codes: 0 ok, 1 error, 2 refusal, 3 not found.

10.2 `README.md` (opening)

Current: “One source of truth for agent-driven work.” — accurate about the mechanism, silent about the category, and it leads with an implementation property rather than the outcome. Recommended opening:

**Commission turns goals into verified software by coordinating the task graph, execution
environment, and shared context of humans and AI agents.**

It is the execution layer for software delivery — not a task tracker with agents
bolted on, and not a coding agent. Agents operate it; humans are asked only for
judgment, and observe through a read-only web view.

Unlike a general tracker, Commission's model is software: dependencies compute what is
workable, gates require evidence before anything can be called done, and the files a
task touches are known before parallel work collides. Unlike a coding agent, Commission
remembers — decisions, dead ends, and acceptance conditions survive the session that
produced them. Unlike a project management tool, its state changes are the operations
themselves: claiming is an atomic lease, and `done` is a predicate that refuses.

The existing “Design rules” section already matches this document and needs no change; it is the paragraph above it that should be replaced.

10.3 Other surfaces

commission prime / CLAUDE.md project vision — already aligned; it is the source the anchor sentence was drawn from. Keep them identical to §1.1 and §1.2.
Website hero (relay-64) — the anchor sentence verbatim as the headline, the tagline as the eyebrow, §1.2 as the subhead. Section order should follow §2, §3, §5.
Docs landing page (relay-58, relay-59) — §1.2 verbatim, then the vocabulary in §6 as the concepts page. The docs must not define these words a second time; they link here.
Pricing and roadmap pages (relay-56, relay-66) — bounded by §8. Nothing from the planned list is described in the present tense.

Appendix: the anchor, restated