decisions file

Authored

The decisions / values layer — the side-ledger of open forks that accrues across ALL phases (Plan 15 MR-4: decisions are not a phase). A fork narrows the live solution space; its options prune a typed reference set (Plan 15 MR-1: architectures | solutions | fillers, instance-declared). Instance extensions narrow via allOf + $ref to this $id with unevaluatedProperties:false.

Authored — Authored by hand — the side-ledger of open forks. 59 fields.

This table is generated at build time from decisions.schema.json — change the schema, and this page changes.

Field	Type	Description
`meta`	object	Header context for the decisions layer — what it is, the principle behind it, and the legend that defines each fork's `scope`.
`title`	string	Title of the decisions layer.
`purpose`	string	What the decisions data is and where it sits relative to the ratings layer.
`status`	string	Maturity note (e.g. HYPOTHESIS until the review).
`principle`	string	The guiding principle (e.g. 'values above, ratings below').
`scopeLegend`	map<string>	Defines the vocabulary of fork `scope` values — each key is a scope an instance uses, each value explains it. The semantic tier enforces forks[].scope ∈ keys(scopeLegend).
`resolutionModes`	map<object>	The ways a fork gets resolved (e.g. 🎯 value / 📊 rating / 🔍 fact) — keyed by mode name. The semantic tier enforces forks[].modes[] ∈ keys(resolutionModes).
`[each value]`	object
`key`	string	The mode key (matches the map key).
`icon`	string	Display glyph for the mode.
`label`	string	Short mode name.
`who`	string	Who owns this kind of decision.
`when`	string	When a fork resolves this way.
`forks` required	array<fork>	The open decisions. Each fork poses a question; choosing an option narrows the live set. Resolution of cross-references (option prune targets, dependsOn.fork, scope, modes) happens in the semantic tier.
`id` required	string	Stable fork id (e.g. F-1).
`title` required	string	Short internal title of the fork.
`question` required	string	The decision question in plain language.
`decides`	string	What resolving this fork actually settles.
`status`	string	Where the fork stands (e.g. 'open', 'delegated to deep-dive').
`modes`	array<string>	Resolution modes that apply — each ∈ keys(resolutionModes) (checked semantically).
`scope`	string	The fork's scope — a key defined in meta.scopeLegend (checked semantically). Typed as string because scope vocabulary is instance-defined.
`dependsOn`	object	Optional gating — this fork only becomes live once another fork has been resolved a certain way.
`fork`	string	The id of the fork this one depends on.
`option`	string	The option key on that fork that activates this one.
`resolvesWith`	string,null	What input resolves the fork (e.g. a deep-dive, a meeting fact), or null if open with no pinned resolver.
`clientCopy`	object	Client-facing register of the fork (title/question/options) — permissive; the shell renders it as the public copy.
`eliminated`	array<object>	Options already ruled out, with the reason — kept for the audit trail.
`key`	string	The eliminated option's key.
`label`	string	The eliminated option's label.
`why`	string	Why it was eliminated.
`options`	array<option>	The choices on this fork. Choosing one keeps its prune set live and drops the rest.
`key` required	string	Stable option key (selected in the cockpit).
`label`	string	Display label for the option.
`note`	string	Optional rationale/detail shown with the option.
`live`	boolean	Whether the option is currently a real, walkable choice (vs. a contrast exhibit).
`default`	boolean	Marks the option taken when the fork is unresolved.
`prune`	object	MR-1 generalized narrowing: which typed set this option keeps live. The kernel intersects `keep` across chosen options of the same set.
`set` required	enum	Which reference set this option narrows. `architectures` · `solutions` · `fillers`
`keep` required	array<string>	The keys (of that set) this option keeps live; resolved against the target file in the semantic tier.
`reviewAgenda`	object	How the forks are organised for a client review — which the client decides, which we resolve by numbers/facts, plus any gate-hinges and meeting facts. Shape is largely instance-specific (ehimare carries gateHinges/meetingFacts); kept permissive here.
`clientDecides`	object	The forks the client must decide, with an ordering note.
`weDecide`	object	The forks we resolve on the client's behalf by rating/fact.
`filters`	array<filter>	Decision-filters — the primitive that narrows the live solution space cockpit-wide (D27, Plan 18). A filter is pure mechanism (no client copy); a meeting ACTIVATES a set of filters and carries the human reason. Optional — a cockpit with no filters is valid.
`id` required	string	Stable filter id, referenced by meetings[].filters[].
`label`	string	Optional short name of the SPECIFIC component this filter checks (e.g. 'Offene API'). When a meeting that activates several filters dims a solution, this names WHICH threshold cut it — it becomes the elimination-reason headline ('[meeting.shortLabel · ]label'), demoting the meeting's note to the hover detail. A label-less filter falls back to the meeting note (legacy shape). A terse mechanism name, not client prose.
`target` required	enum	What the filter acts on — a whole architecture key, a specific solution key, or (target:'property') a value at the `prop` path on each solution. `architecture` · `solution` · `property`
`prop`	string	ONLY for target:'property' — the dotted path to the solution field the filter compares (e.g. 'deployment.saas'). A Plan-19 entry-object at that path is unwrapped to its scalar (avail/cov) before comparison. Required when target='property' (checked in the semantic tier); ignored otherwise.
`mode` required	enum	select = whitelist (matching keys/values survive, the rest are eliminated, intersecting across selects); eliminate = blacklist. For target:'property' + select, a solution whose value is `unknown`/absent is NEVER eliminated — don't eliminate on uncertainty; unknowns surface as a research gap in the Gaps view instead. `select` · `eliminate`
`keys` required	array<string>	For target architecture/solution: the keys named; for target:'property': the ACCEPTABLE VALUES of `prop` (e.g. ['yes']). Resolved/typed in the semantic tier.
`meetings`	array<meeting>	Meeting decisions — each ACTIVATES a set of filters[] (by id) and reaffirms values. Applying a meeting dims everything its filters eliminate, everywhere, reversibly. Optional.
`id` required	string	Stable meeting id (e.g. a date '2026-06-18').
`label` required	string	Short human title of the decision (the card heading, e.g. 'Meeting with Christian').
`shortLabel`	string	Optional terse handle for the filter-set used as the inline elimination-reason prefix (e.g. 'Arbeitsfilter'), distinct from the longer card `label`. Composed as '<shortLabel> · <filter.label>' on a dimmed solution when both are present.
`date`	string	ISO date the decision was taken.
`source`	string	Short attribution shown on a solution this meeting's filters dim (e.g. 'Decision of 18 Jun') — distinct from label, which titles the card.
`note`	string	The reason/summary shown on the decision card and as the dimmed-solution explanation.
`filters` required	array<string>	The filters[].id this meeting activates; resolved in the semantic tier.
`emphasizedValues`	array<string>	Values reaffirmed at the meeting — free prose lines, NOT keys.
`retiresForks`	array<string>	Fork ids this decision retires — DOCUMENTATION ONLY (the audit trail of what the meeting settled). Carries no filtering logic; narrowing is done by filters[].

← Back to the reference