A slice reads a Pack as one design, with the architecture it touches and what each member needs next

actor

A person or an agent running a design pass over features that must be reviewed together.

problem

The Pack page reads member by member, so a reviewer assembles the dependency order, the touched architecture and the open decisions by hand before judging the design as a whole.

outcome

Read a Pack as one design slice: its members and their relations, the components they touch, realized and planned, the decisions and open questions that bound them, and what each member needs for its next rung.

value

A design pass judges the whole before its parts, starting from the members others rest on, and sees how much design each member carries beside its rung without a score.

rule.readingNotArtifact line 48 · specs/consumers/design-slice.sdp.md:48

A design slice is a reading of a set of Specs that a catalog recipe composes from the graph on each invocation; it is never authored, saved or committed, it adds no grouping, namespace, kind, stage or gate, and reading it records nothing.

no example exercises it

rule.scope line 49 · specs/consumers/design-slice.sdp.md:49

A slice takes one scope: a Pack, its resolved members read in authored order, or an ordered list of Spec ids; a Pack scope may be narrowed to an ordered subset of its members, such as the members the perspective filter selects, and then says that it is a subset.

spec:consumers.design-slice.chain · enabled

rule.restsOn line 50 · specs/consumers/design-slice.sdp.md:50

Inside the slice a member rests on each other member it names by refines, dependsOn, constrainedBy or decidedBy, except a refines to a member that names it back by one of the other three, as the statement queue reads them; every relation of those four types between two members is listed with its type, its reason and whether it orders, so a reading tells an ordering link from a relation that orders nothing.

spec:consumers.design-slice.decision-backlink · enabled

rule.depth line 51 · specs/consumers/design-slice.sdp.md:51

A member that rests on no other member has depth 1, as the statement queue's rounds start at 1, and any other member has the depth after the deepest member it rests on; members that reach each other through those links form a cycle, share the depth after the deepest member outside the cycle that any of them rests on, and are listed with one closed path, and the slice refuses nothing.

spec:consumers.design-slice.chain · enabled, spec:consumers.design-slice.decision-backlink · enabled, spec:consumers.design-slice.dependency-cycle · enabled

rule.examplesFold line 52 · specs/consumers/design-slice.sdp.md:52

An example member folds into the member it refines when that refines is its only relation of the four types, in either direction, inside the slice or across its boundary: it is listed among that member's example members and keeps its own row, with its own stated rung, floor reached, stated next rung and holds, and folding lends the member none of them; an example with any other such relation is a member like any other.

spec:consumers.design-slice.folded-example · enabled, spec:consumers.design-slice.independent-example · enabled

rule.memberColumns line 53 · specs/consumers/design-slice.sdp.md:53

Each member carries its stated rung, the floor reached, its stated next rung with the clauses that hold it, its design columns, its rule count as rule coverage counts it, its verifiers and verifying examples with how many are enabled, the units that implement and reference it, and the components those units belong to; the columns are counts and lists beside the rung, never a score, a verdict or a rung.

spec:consumers.design-slice.chain · enabled, spec:consumers.design-slice.folded-example · enabled

rule.boundary line 54 · specs/consumers/design-slice.sdp.md:54

The slice's boundary is built over its members as Pack design builds a Pack's, so a whole Pack's slice has the Pack's boundary; each Spec the slice rests on also carries the floor it reaches and the members whose stated next rung it holds, and a Pack member left out of a narrowed slice is marked as in the Pack.

spec:consumers.design-slice.independent-example · enabled, spec:consumers.design-slice.outside-holding · enabled

rule.touchedComponents line 55 · specs/consumers/design-slice.sdp.md:55

The components a slice touches are the anchored components it reaches three ways, each named on the component's row and never merged: a unit that satisfies or references a member belongs to it; a unit that satisfies a Spec the slice rests on belongs to it; or a member component design names it.

spec:consumers.design-slice.component-absent · enabled, spec:consumers.design-slice.component-differing · enabled, spec:consumers.design-slice.component-matching · enabled, spec:consumers.design-slice.component-unreadable · enabled, spec:consumers.design-slice.component-unrelated · enabled, spec:consumers.design-slice.outside-satisfied · enabled, spec:consumers.design-slice.outside-unbound · enabled

rule.componentDesigns line 56 · specs/consumers/design-slice.sdp.md:56

Every member that is a component design, as the planned-architecture convention selects it, is its own row whether or not code realizes it: the component it names, the layer, context, role and uses it declares, whether an anchor holds that component, whether that anchor satisfies the design, and the realization comparison's differing and unreadable rows for it; a declared value never stands in for an anchored one, nor an anchored value for a declared one.

spec:consumers.design-slice.component-absent · enabled, spec:consumers.design-slice.component-differing · enabled, spec:consumers.design-slice.component-matching · enabled, spec:consumers.design-slice.component-unreadable · enabled, spec:consumers.design-slice.component-unrelated · enabled

rule.touchedUses line 57 · specs/consumers/design-slice.sdp.md:57

Between touched components the slice lists the anchored uses aggregated to component pairs, as the architecture map counts them, a use within one component left out, each pair with the unit edges behind its count; each component a member design declares in uses is a planned use of that design, listed apart from the anchored pairs and never added to their counts.

spec:consumers.design-slice.component-absent · enabled, spec:consumers.design-slice.component-differing · enabled, spec:consumers.design-slice.component-matching · enabled, spec:consumers.design-slice.component-unreadable · enabled, spec:consumers.design-slice.component-unrelated · enabled

rule.outsideNeighbors line 58 · specs/consumers/design-slice.sdp.md:58

A component one uses step from a touched component, in either direction, or named in a member design's uses, that the slice does not touch is listed as outside the slice with how it is reached, and its anchored pairs with touched components are listed and marked outside; the slice reaches no further, and outside components and pairs are counted apart from the touched ones.

spec:consumers.design-slice.component-absent · enabled, spec:consumers.design-slice.component-differing · enabled, spec:consumers.design-slice.component-matching · enabled, spec:consumers.design-slice.component-unreadable · enabled, spec:consumers.design-slice.component-unrelated · enabled, spec:consumers.design-slice.outside-components · enabled, spec:consumers.design-slice.outside-satisfied · enabled

rule.unplaced line 59 · specs/consumers/design-slice.sdp.md:59

A unit that implements or references a member and belongs to no component is listed apart, so no binding drops out of the reading.

no example exercises it

rule.notDownstream line 60 · specs/consumers/design-slice.sdp.md:60

The slice does not count the code of Specs that rest on it: that code follows a change to the slice, and design-change impact reads it; a component that uses a touched component appears only as an outside neighbor.

spec:consumers.design-slice.outside-satisfied · enabled

rule.decisionsInScope line 61 · specs/consumers/design-slice.sdp.md:61

The decisions in scope are the decision members and every decision a member names through decidedBy, each with its stated rung, the floor reached, whether it is a member, the members it shapes, the decisions it refines and supersedes, and its open and blocking question counts.

spec:consumers.design-slice.decision-backlink · enabled

rule.questionsInScope line 62 · specs/consumers/design-slice.sdp.md:62

The open questions in scope are those of every member and of every decision in scope, and the blocking questions of every Spec outside the slice that holds a member's stated next rung, blocking questions first; each carries its address, its fields and the members whose stated next rung its Spec holds.

spec:consumers.design-slice.outside-holding · enabled

rule.noDesignVerdict line 63 · specs/consumers/design-slice.sdp.md:63

The slice shows how much design each member carries and never whether it is enough: it reports no over- or under-designed member, no ratio of design to rung and no finding, because how much to write is the authoring guidance's judgment and checks police conformance and honesty, never content quality.

no example exercises it

rule.graphOnly line 64 · specs/consumers/design-slice.sdp.md:64

The slice reads declared relations, anchored bindings and component designs only; it infers no dependency, component or decision from prose, paths, imports or names.

spec:consumers.design-slice.outside-unbound · enabled

rule.orderAdvisory line 65 · specs/consumers/design-slice.sdp.md:65

Depth gives a reading order, the members others rest on first; it records, schedules and gates nothing, and a member read or designed out of that order is never a finding.

spec:consumers.design-slice.dependency-cycle · enabled

0 unkeyed rules.

Verifying examples

Given a probe Pack whose members {structure: "rest on each other in a chain"}
Given one member depends on an outside Spec {outside: "that no code satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the members read in depth order {order: "spec:probe.base, spec:probe.design, spec:probe.top"}

Given a probe Pack whose members {structure: "rest on each other in a chain"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "no anchor holds"}
When the design slice runs over the probe Pack
Then the member design reads {realized: "unrealized"} with {differing: 0} differing and {unreadable: 0} unreadable rows

Given a probe Pack whose members {structure: "rest on each other in a chain"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, with a differing layer and uses"}
When the design slice runs over the probe Pack
Then the member design reads {realized: "realized"} with {differing: 2} differing and {unreadable: 0} unreadable rows

Given a probe Pack whose members {structure: "rest on each other in a chain"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the member design reads {realized: "realized"} with {differing: 0} differing and {unreadable: 0} unreadable rows

Given a probe Pack whose members {structure: "rest on each other in a chain"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, with an unreadable layer"}
When the design slice runs over the probe Pack
Then the member design reads {realized: "realized"} with {differing: 0} differing and {unreadable: 1} unreadable rows

Given a probe Pack whose members {structure: "rest on each other in a chain"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "an anchor holds without satisfying the design"}
When the design slice runs over the probe Pack
Then the member design reads {realized: "unrealized"} with {differing: 0} differing and {unreadable: 0} unreadable rows

Given a probe Pack whose members {structure: "include a decision that refines the member it shapes"}
Given one member depends on an outside Spec {outside: "that no code satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the members read in depth order {order: "spec:probe.base, spec:probe.design, spec:probe.top"}

Given a probe Pack whose members {structure: "include two members that depend on each other"}
Given one member depends on an outside Spec {outside: "that no code satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the slice reports {cycles: 1} cycles and {exampleMembers: 0} folded example members

Given a probe Pack whose members {structure: "include an example that refines a member"}
Given one member depends on an outside Spec {outside: "that no code satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the slice reports {cycles: 0} cycles and {exampleMembers: 1} folded example members

Given a probe Pack whose members {structure: "include an example that refines a member and depends on an outside Spec"}
Given one member depends on an outside Spec {outside: "that no code satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the slice reports {cycles: 0} cycles and {exampleMembers: 0} folded example members

Given a probe Pack whose members {structure: "include a decision that refines the member it shapes"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "an anchor satisfies, matching every declared value"}
When the design slice runs over the probe Pack
Then the outside components are {outsideComponents: "component:probe.neighbor"}

Given a probe Pack whose members {structure: "include a decision that refines the member it shapes"}
Given one member depends on an outside Spec {outside: "stated below defined"}
Given one member is a component design whose component {anchor: "an anchor holds without satisfying the design"}
When the design slice runs over the probe Pack
Then the outside Spec holds {held: "spec:probe.base"}

Given a probe Pack whose members {structure: "include a decision that refines the member it shapes"}
Given one member depends on an outside Spec {outside: "that a component's unit satisfies"}
Given one member is a component design whose component {anchor: "an anchor holds without satisfying the design"}
When the design slice runs over the probe Pack
Then the touched components are {components: "component:probe.dependency, component:probe.designed"}, {throughRestsOn: 1} of them reached through what the slice rests on

Given a probe Pack whose members {structure: "include a decision that refines the member it shapes"}
Given one member depends on an outside Spec {outside: "that no code satisfies"}
Given one member is a component design whose component {anchor: "an anchor holds without satisfying the design"}
When the design slice runs over the probe Pack
Then the touched components are {components: "component:probe.designed"}, {throughRestsOn: 0} of them reached through what the slice rests on

Example space

Given a probe Pack whose members {structure:"rest on each other in a chain"|"include a decision that refines the member it shapes"|"include two members that depend on each other"|"include an example that refines a member"|"include an example that refines a member and depends on an outside Spec"}
Given one member depends on an outside Spec {outside:"that a component's unit satisfies"|"that no code satisfies"|"stated below defined"}
Given one member is a component design whose component {anchor:"no anchor holds"|"an anchor holds without satisfying the design"|"an anchor satisfies, matching every declared value"|"an anchor satisfies, with a differing layer and uses"|"an anchor satisfies, with an unreadable layer"}
When the design slice runs over the probe Pack
Then the members read in depth order {order:string}
Then the slice reports {cycles:number} cycles and {exampleMembers:number} folded example members
Then the touched components are {components:string}, {throughRestsOn:number} of them reached through what the slice rests on
Then the member design reads {realized:"realized"|"unrealized"} with {differing:number} differing and {unreadable:number} unreadable rows
Then the outside components are {outsideComponents:string}
Then the outside Spec holds {held:string}

sliceRecipe line 69 · specs/consumers/design-slice.sdp.md:69

recipe 54, the design slice, takes exactly one scope, params.pack or params.specs, an optional params.members beside pack, and an optional params.detail; an unknown parameter name returns { unknownParams, accepts } alone, and any input #design.sliceDiagnostics refuses returns { diagnostics } and no slice.

sliceDiagnostics line 70 · specs/consumers/design-slice.sdp.md:70

the checks run in this order and every failure is kept, a check that reads an earlier value being skipped when that value failed: a detail that is present and neither a boolean nor a list of strings, null included, gives { scope: "detail", problem: "Expected true, false or a list of member ids." }; neither or both of pack and specs gives { scope: "scope", problem: "Supply exactly one of pack or specs." }; a pack that is not a string naming a Pack gives { scope: "pack", problem: "Pack does not resolve." }; beside a resolved Pack, a members that is not a non-empty list of distinct strings gives { scope: "members", problem: "Expected a non-empty list of distinct member ids." }, and otherwise each id that is no resolved member gives { scope: <the id>, problem: "Not a resolved member of the Pack." } in list order; a specs that is not a non-empty list of distinct strings gives { scope: "specs", problem: "Expected a non-empty list of distinct Spec ids." }, and otherwise each id the graph does not hold gives { scope: <the id>, problem: "Spec does not resolve." } in list order, as the context bundle names an unresolved id; and a members beside specs gives { scope: "members", problem: "members narrows only a Pack scope." }.

sliceDetail line 71 · specs/consumers/design-slice.sdp.md:71

params.detail is absent or false for the summary, true for every row in full, or a list of member ids for full rows of those members beside summary rows of the rest, an id that is no member adding { id, reason: "not-member" } to the slice's diagnostics, as Pack design reads it; a summary keeps totals whole and adds leftOut, one line for each kind of detail it omits.

no citation recorded

sliceAnswer line 72 · specs/consumers/design-slice.sdp.md:72

{ scope, totals, members, structure, boundary, architecture, decisions, questions }, where scope is { pack, title, framing, subset, members, unresolved } for a Pack, unresolved naming the manifest ids the graph does not hold, and { specs } for a Spec list.

no citation recorded

sliceTotals line 73 · specs/consumers/design-slice.sdp.md:73

{ members, exampleMembers, relations, depth, cycles, heldBelowNextRung, waitingForAuthor, restsOn, holdingOutside, restedOnBy, verifiedBy, supersededBy, components: { touched, throughMembers, throughRestsOn, throughDesigns, outside }, designs: { total, realized, matching, unrealized, differing, unreadable }, componentUses: { inside, outside, planned }, decisions, decisionsBelowReady, openQuestions, blockingQuestions }, where exampleMembers counts folded example members, depth is the deepest member's depth, holdingOutside counts the outside Specs that hold a member, heldBelowNextRung and waitingForAuthor count as Pack design counts them, components.touched counts distinct anchored components however reached and components.outside the outside components, designs counts member designs as the realization comparison's totals count designs, and componentUses counts the anchored pairs inside, the anchored pairs marked outside, and the planned uses.

no citation recorded

memberRow line 74 · specs/consumers/design-slice.sdp.md:74

{ id, title, specKind, altitude, statedReadiness, floorReached, statedNextRung, holds, depth, restsOn, restedOnBy, exampleOf, exampleMembers, design, rules: { total, keyed }, examples: { total, enabled }, verifiers: { total, enabled }, implementedBy, referencedBy, components } in the scope's order, where holds lists the stated-next-rung failures as [{ clauseId, description, targets: [{ type, id, statedReadiness }] }], restsOn and restedOnBy are member ids, exampleOf is the member an example member refines or null, exampleMembers the folded example members, design is the design columns as { entries, declarations, openQuestions, blockingQuestions, decisions } counts, examples the verifying examples bound to the member wherever they sit, apart from exampleMembers, rules.total is the keyed and unkeyed rule and flow entries of the primary behavior owner, implementedBy and referencedBy are unit ids, and components the ids of the components those units belong to.

no citation recorded

memberSummary line 75 · specs/consumers/design-slice.sdp.md:75

{ id, specKind, statedReadiness, floorReached, statedNextRung, holds, depth, restsOn, exampleOf, design, rules, implementedBy, referencedBy } is a member's summary row, with holds as [{ clauseId, targets: [id] }], as Pack design's summary reads it, and implementedBy and referencedBy as counts.

no citation recorded

structureShape line 76 · specs/consumers/design-slice.sdp.md:76

{ edges: [{ from, to, type, orders, reason }], cycles: [{ members, cycle }], unresolved: [{ from, to, type, reason }] }, one edge per declared typed relation between two members, sorted by from, type and to, orders false only for a refines the target names back, and reason present only when the relation states one; cycles in the statement queue's cycle row; a summary drops each edge's reason; unresolved keeps unresolved outgoing typed targets apart from the resolved boundary, with no invented title or rung.

no citation recorded

boundaryRow line 77 · specs/consumers/design-slice.sdp.md:77

Pack design's boundary row { id, title, statedReadiness, implemented, via } with a via that has relation reasons also carrying reasons: [{ member, reason }] for those relations, and with specKind, floorReached, holds, the member ids whose stated-next-rung failures name it as a target, empty outside restsOn, and inPack: true on a Pack member left out of a narrowed slice, in { restsOn, restedOnBy, verifiedBy, supersededBy } sorted by id; a summary keeps { id, statedReadiness, holds } and inPack.

componentRow line 78 · specs/consumers/design-slice.sdp.md:78

{ id, label, layer, context, members: { satisfies, references }, restsOn, designs } sorted by id, one per touched anchored component, where members.satisfies and members.references are the members whose units belong to it by each binding, restsOn the outside Specs the slice rests on whose satisfying units belong to it, designs the member component designs naming it, and label, layer and context come from the architecture map's component row.

no citation recorded

componentSummary line 79 · specs/consumers/design-slice.sdp.md:79

{ id, layer, context, members: { satisfies, references }, restsOn, designs }, each list replaced by its count and label left out.

no citation recorded

designRow line 80 · specs/consumers/design-slice.sdp.md:80

{ spec, componentId, layer, context, role, uses, anchorExists, realized, differing, unreadable } sorted by spec, one per member component design, where the declared values are read as spec:model.planned-architecture#design.designKeys reads them, null when unstated or unreadable and uses an empty list for none, realized holds as spec:model.planned-architecture#design.realizedWhen says, differing lists the comparison's { field, planned, realized } rows for the design and unreadable its { key, value } rows; a summary keeps { spec, componentId, anchorExists, realized } and the two lists as counts.

no citation recorded

componentUse line 81 · specs/consumers/design-slice.sdp.md:81

{ from, to, count, outside, units } sorted by from and to, one per pair of components with an anchored uses between them and at least one end touched, where count is the architecture map's count of unit uses edges for the pair, units lists those edges as { from, to, claim } from the architecture map's usesEdges, and outside is true when one end is not touched; a summary drops units.

no citation recorded

plannedUse line 82 · specs/consumers/design-slice.sdp.md:82

{ design, from, to, outside } sorted by from, to and design, one per component a member design declares in uses other than its own, where from is the component the design names and outside is true when to is neither touched nor named by a member design.

no citation recorded

outsideRow line 83 · specs/consumers/design-slice.sdp.md:83

{ id, label, layer, context, anchored, reachedBy } sorted by id, where reachedBy lists, in this order, touchedUses when a touched component uses it, usesTouched when it uses a touched component, and plannedUse when a member design declares it, and anchored says whether an anchor holds it; a summary keeps { id, anchored, reachedBy }.

no citation recorded

architectureShape line 84 · specs/consumers/design-slice.sdp.md:84

{ components, designs, uses, plannedUses, outside, unplaced }, where unplaced lists { unit, member, via }, via being satisfies or references, for each unit of a member that belongs to no component.

no citation recorded

decisionRow line 85 · specs/consumers/design-slice.sdp.md:85

{ id, title, statedReadiness, floorReached, member, shapes, refines, supersedes, supersededBy, openQuestions, blockingQuestions } sorted by id, where shapes lists the members that name the decision through decidedBy and the next three lists come from its decision register row; a summary keeps { id, statedReadiness, member, shapes } with shapes as a count.

no citation recorded

questionRow line 86 · specs/consumers/design-slice.sdp.md:86

{ address, spec, origin, index, question, blocking, deferral, decider, links, provisional, trigger, holds } with the open-question register's fields, where origin is member, decision or restsOn, index the question's authored position from 0, address null without a key, and holds the members whose stated next rung its Spec holds when the question blocks, its own Spec first when that Spec is a member held by the floor's blocking-question clause, empty for a non-blocking question; rows sort blocking first, then by how many members they hold, then by Spec id and position; a summary keeps a non-blocking question as { address, spec, index }.

no citation recorded

Verifier bindings

• spec:consumers.design-slice.chain · Members rest on a chain · declared · example enabled · specs/consumers/design-slice.chain.sdp.md

  External run evidence from test/self-hosting-design-slice.test.ts

  Test anchors: test:protocol.design-slice, test:protocol.design-slice.chain, test:protocol.design-slice.component-absent, test:protocol.design-slice.component-differing, test:protocol.design-slice.component-matching, test:protocol.design-slice.component-unreadable, test:protocol.design-slice.component-unrelated, test:protocol.design-slice.decision-backlink, test:protocol.design-slice.dependency-cycle, test:protocol.design-slice.folded-example, test:protocol.design-slice.independent-example, test:protocol.design-slice.outside-components, test:protocol.design-slice.outside-holding, test:protocol.design-slice.outside-satisfied, test:protocol.design-slice.outside-unbound. Specs verified by those bindings: spec:consumers.design-slice, spec:consumers.design-slice.chain, spec:consumers.design-slice.component-absent, spec:consumers.design-slice.component-differing, spec:consumers.design-slice.component-matching, spec:consumers.design-slice.component-unreadable, spec:consumers.design-slice.component-unrelated, spec:consumers.design-slice.decision-backlink, spec:consumers.design-slice.dependency-cycle, spec:consumers.design-slice.folded-example, spec:consumers.design-slice.independent-example, spec:consumers.design-slice.outside-components, spec:consumers.design-slice.outside-holding, spec:consumers.design-slice.outside-satisfied, spec:consumers.design-slice.outside-unbound.

  Run 1: external run evidence from vitest 4.1.10

  Build: CI 391 · Branch: cursor/media-plan-and-articles-09b1 · Commit: 076cd4f1f85640d8236e5cca1bffffa68ab79a33 · Start: 2026-10-31T15:32:20.471Z · Stop: 2026-10-31T15:34:02.073Z

  Name	Suite	Result	Duration
  keeps authored order while assigning depth and composing whole-Pack boundary	design slice	passed	44.88 ms
  keeps summary totals, selected full members and explicit omissions	design slice	passed	37.9 ms
  reads an ordered Spec list and a narrowed Pack, marking excluded Pack members	design slice	passed	8.52 ms
  only suppresses a refinement the target answers with dependsOn	design slice	passed	3.91 ms
  only suppresses a refinement the target answers with constrainedBy	design slice	passed	3.6 ms
  only suppresses a refinement the target answers with decidedBy	design slice	passed	3.77 ms
  lists cycles at the depth after their deepest outside prerequisite	design slice	passed	5.52 ms
  does not fold an example with another refines in either direction or across the boundary	design slice	passed	9.85 ms
  does not fold an example with another dependsOn in either direction or across the boundary	design slice	passed	8.16 ms
  does not fold an example with another constrainedBy in either direction or across the boundary	design slice	passed	11.15 ms
  does not fold an example with another decidedBy in either direction or across the boundary	design slice	passed	17.53 ms
  accumulates diagnostics in contract order and skips dependent checks	design slice	passed	47.44 ms
  pins the component Design grammar and totals to recipe 43	design slice	passed	59.6 ms
  executes the bound example against a fresh world	Outside components stop at the touched components' neighbors (spec:consumers.design-slice.outside-components)	passed	9.76 ms
  executes the bound example against a fresh world	Members rest on a chain (spec:consumers.design-slice.chain)	passed	11.33 ms
  executes the bound example against a fresh world	A shaping decision comes before its member (spec:consumers.design-slice.decision-backlink)	passed	5.84 ms
  executes the bound example against a fresh world	A cycle shares a depth (spec:consumers.design-slice.dependency-cycle)	passed	3.66 ms
  executes the bound example against a fresh world	An example folds without lending its readiness (spec:consumers.design-slice.folded-example)	passed	7.62 ms
  executes the bound example against a fresh world	An example with its own dependency stays unfolded (spec:consumers.design-slice.independent-example)	passed	4.43 ms
  executes the bound example against a fresh world	An unanchored component design stays visible (spec:consumers.design-slice.component-absent)	passed	5.36 ms
  executes the bound example against a fresh world	An anchor alone does not realize a component design (spec:consumers.design-slice.component-unrelated)	passed	6.17 ms
  executes the bound example against a fresh world	A realized component matches its declared values (spec:consumers.design-slice.component-matching)	passed	10.64 ms
  executes the bound example against a fresh world	A realized component keeps its differing layer and uses apart (spec:consumers.design-slice.component-differing)	passed	7.66 ms
  executes the bound example against a fresh world	An unreadable declared layer stays visible (spec:consumers.design-slice.component-unreadable)	passed	9.45 ms
  executes the bound example against a fresh world	A prerequisite reaches its satisfying component (spec:consumers.design-slice.outside-satisfied)	passed	4.75 ms
  executes the bound example against a fresh world	An unbound prerequisite invents no component (spec:consumers.design-slice.outside-unbound)	passed	3.99 ms
  executes the bound example against a fresh world	An outside prerequisite names the member it holds (spec:consumers.design-slice.outside-holding)	passed	4.46 ms
  keeps unresolved targets and boundary relation reasons in the recipe answer	design slice composition	passed	4.1 ms
  keeps bindings to unresolved components unplaced rather than touching an invented component	design slice composition	passed	3.43 ms
  pins every full and summary row shape to the carrying Design entries	design slice composition	passed	47.9 ms
  reports outside holds, waiting statements, decision replacements and own-Spec question holds	design slice composition	passed	16.07 ms
  the executable order observation rejects rest on each other in a chain with setDepth[index] = 1;	design slice composition	passed	7.51 ms
  the executable order observation rejects include a decision that refines the member it shapes with setDepth[index] = 1;	design slice composition	passed	10.16 ms
  the executable order observation rejects include a decision that refines the member it shapes with edge.orders = true;	design slice composition	passed	13.64 ms
  the executable assertions reject missing rest on each other in a chain evidence for scope	design slice composition	passed	7.78 ms
  the executable assertions reject missing rest on each other in a chain evidence for memberColumns	design slice composition	passed	4.12 ms
  the executable assertions reject missing include a decision that refines the member it shapes evidence for decisionsInScope	design slice composition	passed	5.14 ms
  the executable assertions reject missing include an example that refines a member and depends on an outside Spec evidence for boundary	design slice composition	passed	10.03 ms
  the executable assertions reject missing include two members that depend on each other evidence for depth	design slice composition	passed	9.38 ms
  counts only example-kind declared verifiers as examples, keeping all verifiers	design slice composition	passed	15.99 ms
  names the hold detail and decision shape lists the summary omits	design slice composition	passed	3.72 ms
  summarizes component and design rows without losing totals	design slice composition	passed	17.3 ms
  keeps all binding paths, unplaced units, pair counts and planned uses apart	design slice composition	passed	5.14 ms
  reads outside decisions and orders their questions before non-blocking member questions	design slice composition	passed	5.7 ms
  reads declared values with the realization comparison grammar: {"layer":"`domain` explanation","context":"``probe`` explanation","role":"service","uses":"`none` explanation"}	design slice composition	passed	6.97 ms
  reads declared values with the realization comparison grammar: {"layer":"Domain","context":"Bad","role":"bad_role","uses":"component:probe.bad, invalid"}	design slice composition	passed	5.75 ms
  reads declared values with the realization comparison grammar: {"uses":"component:probe.z, component:probe.a, component:probe.z"}	design slice composition	passed	5.33 ms
  reads declared values with the realization comparison grammar: {}	design slice composition	passed	4.58 ms

• spec:consumers.design-slice.component-absent · An unanchored component design stays visible · declared · example enabled · specs/consumers/design-slice.component-absent.sdp.md
• spec:consumers.design-slice.component-differing · A realized component keeps its differing layer and uses apart · declared · example enabled · specs/consumers/design-slice.component-differing.sdp.md
• spec:consumers.design-slice.component-matching · A realized component matches its declared values · declared · example enabled · specs/consumers/design-slice.component-matching.sdp.md
• spec:consumers.design-slice.component-unreadable · An unreadable declared layer stays visible · declared · example enabled · specs/consumers/design-slice.component-unreadable.sdp.md
• spec:consumers.design-slice.component-unrelated · An anchor alone does not realize a component design · declared · example enabled · specs/consumers/design-slice.component-unrelated.sdp.md
• spec:consumers.design-slice.decision-backlink · A shaping decision comes before its member · declared · example enabled · specs/consumers/design-slice.decision-backlink.sdp.md
• spec:consumers.design-slice.dependency-cycle · A cycle shares a depth · declared · example enabled · specs/consumers/design-slice.dependency-cycle.sdp.md
• spec:consumers.design-slice.folded-example · An example folds without lending its readiness · declared · example enabled · specs/consumers/design-slice.folded-example.sdp.md
• spec:consumers.design-slice.independent-example · An example with its own dependency stays unfolded · declared · example enabled · specs/consumers/design-slice.independent-example.sdp.md
• spec:consumers.design-slice.outside-components · Outside components stop at the touched components' neighbors · declared · example enabled · specs/consumers/design-slice.outside-components.sdp.md
• spec:consumers.design-slice.outside-holding · An outside prerequisite names the member it holds · declared · example enabled · specs/consumers/design-slice.outside-holding.sdp.md
• spec:consumers.design-slice.outside-satisfied · A prerequisite reaches its satisfying component · declared · example enabled · specs/consumers/design-slice.outside-satisfied.sdp.md
• spec:consumers.design-slice.outside-unbound · An unbound prerequisite invents no component · declared · example enabled · specs/consumers/design-slice.outside-unbound.sdp.md
• test:protocol.design-slice · anchored · test anchor binding present · test/self-hosting-design-slice.test.ts:155

Requirement drawing

Decisions

• Bindings are optional, plural, and may reference a design

  On a code anchor, satisfies is optional and plural; on a test anchor, verifies is plural and non-empty. The constant form accepts one ref(…) or a fresh array literal of them. Each resolving target confers its fact, and implemented stays a whole-Spec fact. An anchored edge references runs from a CodeNode to a Spec, from references?: readonly SpecId[] on a code anchor; it may target any Spec, decisions included, confers no delivery fact, moves no readiness floor, and the drift alarm ignores it. It says this code answers to that design without claiming to realize it: the unit follows the design without realizing any of its promises, or realizes part of a Spec whose remaining promises no unit yet realizes, so a change to the design asks the code to follow. A design that builds on existing code states that by a typed relation to the Spec the code satisfies, never by a reference from the code. A target named in both satisfies and references is an error. An identity-only code anchor, with no satisfies and no references, is lawful: it mints a CodeNode for structure and for byFile, and nothing else.

• Architectural significance is annotated where it is realized

  Architectural significance is annotated on the anchor of the unit that realizes it. A code anchor may carry role, the architectural pattern the unit plays; a component: anchor may additionally carry layer, one of edge, application, domain, adapter, or infrastructure, and context, its bounded context. The component: anchor is anchored architecture: it is the declared component, and there is no separate architecture file, because the anchor sits where the component is realized. It is not the original design's declared Component that could exist before code; an unrealized component lives in Specs and never as an invented CodeNode. A role is a free, corpus-owned vocabulary whose taxonomy the census renders with counts from the graph; service, decider, projection, read-model, codec, contract, barrel, and utility are the lineage set, not a closed list. layer is a closed set, and a value outside it is an envelope error; layer or context on a non-component anchor is an envelope error. All three attributes are optional, and omission is lawful.

• impl:protocol.design-slice-recipe · realizes the design slice in the shipped recipe catalog · test/self-hosting-design-slice.test.ts:148

  Uses

  None.

Runtime observation: not tracked.

Runtime observation: not tracked.

Build attestations: not tracked.

Deployments: not tracked.

Bills of materials: not tracked.