@thebackstoryis/engineering-with-ai 0.2.9

package/src/validation-config.mjs

@@ -0,0 +1,289 @@
+export const VALIDATION_PROVIDERS = Object.freeze(['claude', 'codex', 'antigravity']);
+
+const LEGACY_PROVIDER_ALIASES = Object.freeze({
+  gemini: 'antigravity',
+  agy: 'antigravity',
+});
+
+export function canonicalValidationProvider(provider) {
+  const value = String(provider ?? '').trim().toLowerCase();
+  return LEGACY_PROVIDER_ALIASES[value] ?? value;
+}
+
+export const VALIDATION_CHECKPOINTS = Object.freeze({
+  'implementation-plan': 'validate-external-plan',
+  'test-plan': 'validate-external-test-plan',
+  code: 'validate-external-code',
+});
+
+export const VALIDATION_BREADTHS = Object.freeze([
+  'targeted',
+  'change-set',
+  'capability',
+  'system',
+]);
+
+export const VALIDATION_DEPTHS = Object.freeze([
+  'issues-only',
+  'issues-and-fixes',
+  'analysis-and-recommendations',
+]);
+
+export const VALIDATION_OUTPUTS = Object.freeze(['small', 'medium', 'large']);
+
+const DEFAULT_CHECKPOINTS = Object.freeze({
+  'implementation-plan': {
+    enabled: true,
+    max_cycles: 2,
+    validators: 'auto',
+    review: {
+      breadth: 'capability',
+      depth: 'issues-and-fixes',
+      output: 'medium',
+    },
+  },
+  'test-plan': {
+    enabled: true,
+    max_cycles: 2,
+    validators: 'auto',
+    review: {
+      breadth: 'capability',
+      depth: 'issues-and-fixes',
+      output: 'medium',
+    },
+  },
+  code: {
+    enabled: true,
+    max_cycles: 2,
+    validators: 'auto',
+    review: {
+      breadth: 'change-set',
+      depth: 'issues-and-fixes',
+      output: 'medium',
+    },
+  },
+});
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function requireEnum(value, allowed, label) {
+  if (!allowed.includes(value)) {
+    throw new Error(`${label} must be one of: ${allowed.join(', ')}`);
+  }
+  return value;
+}
+
+function normaliseProvider(value, provider) {
+  if (typeof value === 'string') {
+    requireEnum(value, ['available', 'unavailable'], `validation provider ${provider}`);
+    return {
+      state: value,
+      enabled: value === 'available',
+    };
+  }
+
+  const state = value?.state ?? 'unavailable';
+  requireEnum(state, ['available', 'unavailable'], `validation provider ${provider} state`);
+  if (value?.enabled !== undefined && typeof value.enabled !== 'boolean') {
+    throw new Error(`validation provider ${provider} enabled must be true or false`);
+  }
+  const enabled = state === 'available' && (value?.enabled ?? true);
+
+  return { state, enabled };
+}
+
+function normaliseValidators(value, checkpoint) {
+  if (value === undefined || value === 'auto') {
+    return 'auto';
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`validation checkpoint ${checkpoint} validators must be "auto" or an array`);
+  }
+
+  const validators = [...new Set(value.map(canonicalValidationProvider))];
+  for (const provider of validators) {
+    requireEnum(provider, VALIDATION_PROVIDERS, `validation checkpoint ${checkpoint} validator`);
+  }
+  return validators;
+}
+
+function normaliseCheckpoint(value, checkpoint) {
+  const defaults = DEFAULT_CHECKPOINTS[checkpoint];
+  const review = value?.review ?? {};
+  if (value?.enabled !== undefined && typeof value.enabled !== 'boolean') {
+    throw new Error(`validation checkpoint ${checkpoint} enabled must be true or false`);
+  }
+  const maxCycles = value?.max_cycles ?? defaults.max_cycles;
+  if (!Number.isInteger(maxCycles) || maxCycles < 1 || maxCycles > 3) {
+    throw new Error(`validation checkpoint ${checkpoint} max_cycles must be an integer from 1 to 3`);
+  }
+
+  return {
+    enabled: value?.enabled ?? defaults.enabled,
+    max_cycles: maxCycles,
+    validators: normaliseValidators(value?.validators, checkpoint),
+    review: {
+      breadth: requireEnum(
+        review.breadth ?? defaults.review.breadth,
+        VALIDATION_BREADTHS,
+        `validation checkpoint ${checkpoint} review breadth`,
+      ),
+      depth: requireEnum(
+        review.depth ?? defaults.review.depth,
+        VALIDATION_DEPTHS,
+        `validation checkpoint ${checkpoint} review depth`,
+      ),
+      output: requireEnum(
+        review.output ?? defaults.review.output,
+        VALIDATION_OUTPUTS,
+        `validation checkpoint ${checkpoint} review output`,
+      ),
+    },
+  };
+}
+
+export function defaultValidationConfig() {
+  return {
+    standards: {
+      required: true,
+      allow_waiver: false,
+    },
+    external: {
+      policy: 'configured',
+      independent_only: true,
+      providers: Object.fromEntries(
+        VALIDATION_PROVIDERS.map((provider) => [
+          provider,
+          { state: 'unavailable', enabled: false },
+        ]),
+      ),
+      checkpoints: clone(DEFAULT_CHECKPOINTS),
+    },
+  };
+}
+
+export function normaliseValidationConfig(value = {}) {
+  if (value?.standards?.required === false) {
+    throw new Error('Standards compliance is mandatory and cannot be disabled');
+  }
+  if (value?.standards?.allow_waiver === true) {
+    throw new Error('Standards compliance cannot be waived');
+  }
+  if (value?.external?.independent_only === false) {
+    throw new Error('External validation must remain independent of the orchestrator');
+  }
+
+  const rawProviders = value?.external?.providers ?? {};
+  const providers = Object.fromEntries(
+    VALIDATION_PROVIDERS.map((provider) => [
+      provider,
+      normaliseProvider(
+        rawProviders[provider] ?? (provider === 'antigravity' ? rawProviders.gemini : undefined),
+        provider,
+      ),
+    ]),
+  );
+
+  const rawCheckpoints = value?.external?.checkpoints ?? {};
+  const checkpoints = Object.fromEntries(
+    Object.keys(VALIDATION_CHECKPOINTS).map((checkpoint) => [
+      checkpoint,
+      normaliseCheckpoint(rawCheckpoints[checkpoint], checkpoint),
+    ]),
+  );
+
+  return {
+    standards: {
+      required: true,
+      allow_waiver: false,
+    },
+    external: {
+      policy: 'configured',
+      independent_only: true,
+      providers,
+      checkpoints,
+    },
+  };
+}
+
+export function validationCheckpointForPhase(phaseId) {
+  return Object.entries(VALIDATION_CHECKPOINTS)
+    .find(([, configuredPhase]) => configuredPhase === phaseId)?.[0] ?? null;
+}
+
+export function effectiveValidationConfig(configOrValidation, orchestrator = 'manual') {
+  const validation = normaliseValidationConfig(
+    configOrValidation?.validation ?? configOrValidation,
+  );
+  const canonicalOrchestrator = canonicalValidationProvider(orchestrator);
+  const normalisedOrchestrator = VALIDATION_PROVIDERS.includes(canonicalOrchestrator)
+    ? canonicalOrchestrator
+    : 'manual';
+
+  const globallyEligible = VALIDATION_PROVIDERS.filter((provider) => {
+    const setting = validation.external.providers[provider];
+    return setting.state === 'available' && setting.enabled;
+  });
+
+  const checkpoints = Object.fromEntries(
+    Object.entries(validation.external.checkpoints).map(([checkpoint, setting]) => {
+      const requested = setting.validators === 'auto'
+        ? globallyEligible
+        : setting.validators.filter((provider) => globallyEligible.includes(provider));
+      const providers = requested.filter((provider) => provider !== normalisedOrchestrator);
+
+      return [
+        checkpoint,
+        {
+          phase: VALIDATION_CHECKPOINTS[checkpoint],
+          enabled: setting.enabled,
+          max_cycles: setting.max_cycles,
+          validators: providers,
+          review: clone(setting.review),
+          skipped_orchestrator: requested.includes(normalisedOrchestrator)
+            ? normalisedOrchestrator
+            : null,
+        },
+      ];
+    }),
+  );
+
+  return {
+    standards: clone(validation.standards),
+    orchestrator: normalisedOrchestrator,
+    providers: clone(validation.external.providers),
+    checkpoints,
+  };
+}
+
+export function setValidationProvider(config, provider, state, enabled = undefined) {
+  requireEnum(provider, VALIDATION_PROVIDERS, 'validation provider');
+  requireEnum(state, ['available', 'unavailable'], 'validation provider state');
+  const validation = normaliseValidationConfig(config.validation);
+  validation.external.providers[provider] = {
+    state,
+    enabled: state === 'available' ? (enabled ?? true) : false,
+  };
+  config.validation = validation;
+  return config;
+}
+
+export function setValidationCheckpoint(config, checkpoint, update) {
+  requireEnum(checkpoint, Object.keys(VALIDATION_CHECKPOINTS), 'validation checkpoint');
+  const validation = normaliseValidationConfig(config.validation);
+  validation.external.checkpoints[checkpoint] = normaliseCheckpoint(
+    {
+      ...validation.external.checkpoints[checkpoint],
+      ...update,
+      review: {
+        ...validation.external.checkpoints[checkpoint].review,
+        ...(update.review ?? {}),
+      },
+    },
+    checkpoint,
+  );
+  config.validation = validation;
+  return config;
+}

package/templates/SPECS/1.Scope/personas/registry.yaml

@@ -0,0 +1,12 @@
+schema: ewai.persona-registry/v1
+sources:
+  - id: project
+    path: project
+    managed: false
+  - id: personal
+    scope: user
+    managed: false
+  - id: premium
+    pack: ewai.personas.professional
+    managed: true
+assignments: {}

package/templates/SPECS/5.Strategy/patterns/context-packet.md

@@ -0,0 +1,119 @@
+# Context Packet Pattern
+
+> SPECS 5.Strategy / patterns
+> Status: EWAI v1
+
+## Purpose
+
+Give every phase and contributor involved in a capability one living artefact that summarises the current delivery run. It prevents each AI or person from re-deriving context and keeps resumable work intelligible.
+
+The Context Packet is distinct from:
+
+- `tracker.md`, the phase-status state machine;
+- phase artefacts such as `intent-summary.md` and `build-plan.md`;
+- ADRs, which hold durable cross-capability decisions;
+- agent memory, which is not project truth.
+
+It lives at `SPECS/6.Build/{slug}/context-packet.md`, is created beside the tracker, is read on every phase entry, and is updated on every phase exit.
+
+## Required structure
+
+The packet uses these sections in this order:
+
+```markdown
+# Context Packet: {Capability Name}
+
+**Slug:** `{slug}`
+**Started:** {ISO timestamp}
+**Last updated:** {ISO timestamp}
+**Current phase:** {phase or paused state}
+**Review intensity:** {full | scoped | targeted}
+**Execution tier:** {full | scoped | targeted}
+**Input type:** {intent | capability | idea | bug | resume}
+**Run mode:** {normal | dry-run | shelf | bug | resume}
+**Branch strategy:** {n/a | no-build-branches | branches-created-at-shelf}
+**Working branch:** {main | feature/{slug} | mixed; explain}
+
+---
+
+## What this capability is
+
+{One plain-language paragraph from the accepted intent.}
+
+## Why it matters
+
+{Business rationale, beneficiaries, and what fails without it.}
+
+## Scope boundary
+
+**In scope:**
+- {item}
+
+**Out of scope (explicitly deferred):**
+- {item}: {reason and destination}
+
+## Key decisions made during this run
+
+| # | Decision | Made during | Rationale | Reversibility |
+|---|---|---|---|---|
+
+## Open escalations
+
+| # | Phase raised | Question | Status | Resolution |
+|---|---|---|---|---|
+
+## Phase log
+
+| Phase | Status | Started | Completed | Key artefact | Notes |
+|---|---|---|---|---|---|
+
+## Active constraints
+
+- {binding constraint downstream phases must retain}
+
+## Push-back signals
+
+| # | Phase / tool | Reference file | Nature of push-back | What we did instead | Proposed update |
+|---|---|---|---|---|---|
+
+## Handoff notes
+
+`{phase} → {next phase}: {three to five useful sentences}`
+
+## Links
+
+- Tracker: `tracker.md`
+- Durable state: `delivery-state.json`
+- Destination: `destination.md` (after Plan)
+- Task graph: `task-graph.json` (after Plan)
+- Intent: `intent-summary.md`
+- Build plan: `build-plan.md` (after Plan)
+- Test plan: `test-plan.md` (after TestPlan)
+- Task reports: `tasks/T-###/report.md` (during Build)
+- Retro: `retro.md` (after completion)
+```
+
+## Maintenance protocol
+
+On entry, read the packet and use it as the primary brief. Open referenced artefacts where more detail is required. Before repository-truth claims, query the project-local EWAI index and verify material evidence in source.
+
+On exit, update:
+
+- timestamp and current phase;
+- the completed phase-log row;
+- new decisions and their reversibility;
+- active constraints and open escalations;
+- newly created links;
+- the handoff for the next phase.
+
+On escalation, record the question and exact paused phase. On resume, validate the packet against `delivery-state.json`, the intent Markdown and JSON, and SQLite. The JSON and guarded transition checks decide whether work may proceed; this Markdown makes the state legible.
+
+Contributors and subagents do not mutate the packet directly. They return evidence to the orchestrator, which is its single writer. Tracker, Context Packet, checklist, gate ledgers, and branch merges are sequentially owned surfaces.
+
+## Retention
+
+Archive the packet with all other delivery evidence after Retro. It remains the readable account of how the capability moved through the pipeline.
+
+## Exclusions
+
+Do not put long analysis, code, per-task execution detail, cross-capability ADR content, hidden agent memory, or speculative ideas in this packet. Keep it under 300 lines; move depth into a linked artefact.

package/templates/SPECS/6.Build/_tracker-template.md

@@ -0,0 +1,16 @@
+---
+schema: ewai.tracker/v1
+slug: ""
+status: preparing
+current_phase: intent
+---
+
+# Delivery tracker
+
+## Outcome
+
+## Phase state
+
+## Decisions
+
+## Blockers

package/templates/SPECS/pipeline.yaml

@@ -0,0 +1,62 @@
+schema: ewai.project/v1
+project:
+  name: {{PROJECT_NAME}}
+specs:
+  root: {{SPECS_ROOT}}
+repositories:
+  - name: {{PRIMARY_REPOSITORY_NAME}}
+    path: {{PRIMARY_REPOSITORY_PATH}}
+    role: {{PRIMARY_REPOSITORY_ROLE}}
+skills:
+  namespace: ewai
+  profile: full
+packs:
+  - ewai.core
+personas:
+  premium:
+    provider: wordpress-edd
+approvals:
+  build: required
+  destructive_operations: required
+validation:
+  standards:
+    required: true
+    allow_waiver: false
+  external:
+    policy: configured
+    independent_only: true
+    providers:
+      claude:
+        state: unavailable
+        enabled: false
+      codex:
+        state: unavailable
+        enabled: false
+      antigravity:
+        state: unavailable
+        enabled: false
+    checkpoints:
+      implementation-plan:
+        enabled: true
+        max_cycles: 2
+        validators: auto
+        review:
+          breadth: capability
+          depth: issues-and-fixes
+          output: medium
+      test-plan:
+        enabled: true
+        max_cycles: 2
+        validators: auto
+        review:
+          breadth: capability
+          depth: issues-and-fixes
+          output: medium
+      code:
+        enabled: true
+        max_cycles: 2
+        validators: auto
+        review:
+          breadth: change-set
+          depth: issues-and-fixes
+          output: medium

package/templates/discovery-answers.yaml

@@ -0,0 +1,86 @@
+schema: ewai.discovery-answers/v1
+project:
+  name: Example Product
+  whyNow: Explain what changed or became unacceptable.
+  purpose: Help a defined group of users achieve a valuable outcome.
+  problem: Describe the current unmet need and why it matters.
+  primaryUsers:
+    - Primary user
+  desiredOutcomes:
+    - Measurable outcome
+  inScope:
+    - Primary project boundary
+  capabilities:
+    - Required capability
+  missingCapabilities: []
+  stage: new
+  productTypes:
+    - web application
+  nonGoals: []
+  dontTouch: []
+  hardConstraints: []
+  softConstraints: []
+  nonNegotiables: []
+  successSignals:
+    - Observable evidence of the desired outcome
+  failureSignals: []
+  definitionOfReady: []
+  definitionOfDone:
+    - Delivery gates pass
+    - Manual QA is approved
+    - Retrospective is complete
+  openQuestions: []
+  risks: []
+  oneSentence: A one-sentence honest description of the project.
+  avoidBecoming: A solution detached from the real user problem.
+  ownership:
+    product: Product owner name or role
+    delivery: Delivery owner name or role
+    technical: Technical owner name or role
+delivery:
+  technologyPacks:
+    - ewai.stack.laravel-nuxt
+  customTechnology: []
+  deploymentTarget: Managed cloud platform
+  constraints: []
+assurance:
+  jurisdictions:
+    - United Kingdom
+  regulatedDomains: []
+  dataClassification: confidential
+  personalData: yes
+  sensitiveData: unknown
+  authentication: yes
+  multiTenant: yes
+  internetFacing: yes
+  payments: no
+  aiFeatures: no
+  accessibility: yes
+  availability: standard
+validation:
+  providers:
+    claude:
+      state: unavailable
+      enabled: false
+    codex:
+      state: unavailable
+      enabled: false
+    antigravity:
+      state: unavailable
+      enabled: false
+  checkpoints:
+    implementation-plan:
+      max_cycles: 2
+      breadth: capability
+      depth: issues-and-fixes
+      output: medium
+    test-plan:
+      max_cycles: 2
+      breadth: capability
+      depth: issues-and-fixes
+      output: medium
+    code:
+      max_cycles: 2
+      breadth: change-set
+      depth: issues-and-fixes
+      output: medium

package/templates/intent-body.md

@@ -0,0 +1,21 @@
+# {{TITLE}}
+
+## Problem
+
+## Desired outcome
+
+## Users and personas
+
+## Journeys
+
+## Acceptance criteria
+
+## Constraints
+
+## Dependencies and relationships
+
+## Delivery shape preview
+
+## Evidence
+
+## Open decisions

package/tests/fixtures/context-benchmarks.json

@@ -0,0 +1,9 @@
+[
+  {"profile":"companion","focus":"continue governed delivery","budgetTokens":150,"segments":[{"id":"companion-state","label":"Current state","evidenceClass":"mandatory","priority":100,"sourcePath":"SPECS/6.Build/example/delivery-state.json","content":"MANDATORY:COMPANION CURRENT_PHASE plan HUMAN_ROUTE continue","requiredMarkers":["MANDATORY:COMPANION","CURRENT_PHASE","HUMAN_ROUTE"],"selectionReason":"Current state and human route are required."},{"id":"companion-focus","label":"Current focus","evidenceClass":"relevant","priority":60,"sourcePath":"SPECS/6.Build/example/context-packet.md","content":"FOCUS governed delivery next action and blocker","selectionReason":"Matches current work."},{"id":"companion-history","label":"Repeated history","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/3.Evidence/history.md","content":"Historical delivery narrative already represented by current state. ","repeat":80,"selectionReason":"Only useful with spare budget."}]},
+  {"profile":"intent","focus":"define context outcome","budgetTokens":170,"segments":[{"id":"intent-outcome","label":"Outcome and acceptance","evidenceClass":"mandatory","priority":100,"sourcePath":"SPECS/2.Purpose/intents/example.md","content":"MANDATORY:INTENT OUTCOME minimum sufficient context ACCEPTANCE no engineering regression","requiredMarkers":["MANDATORY:INTENT","OUTCOME","ACCEPTANCE"],"selectionReason":"Outcome and acceptance are required."},{"id":"intent-personas","label":"Relevant personas","evidenceClass":"relevant","priority":60,"sourcePath":"SPECS/1.Scope/personas/project.md","content":"PERSONAS product owner maintainer operator curator","selectionReason":"Relevant lenses refine the intent."},{"id":"intent-notes","label":"Raw ideation","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/2.Purpose/ideas/example.md","content":"Repeated ideation notes superseded by reviewed outcome. ","repeat":80,"selectionReason":"Background only."}]},
+  {"profile":"plan","focus":"plan context assembly","budgetTokens":190,"segments":[{"id":"plan-contract","label":"Plan contract","evidenceClass":"mandatory","priority":100,"sourcePath":"SPECS/6.Build/example/build-plan.md","content":"MANDATORY:PLAN SLICE GCA-S1 STANDARD lifecycle safety TEST first failing test","requiredMarkers":["MANDATORY:PLAN","SLICE","STANDARD","TEST"],"selectionReason":"Slices standards and tests are required."},{"id":"plan-truth","label":"Repository truth","evidenceClass":"relevant","priority":70,"sourcePath":"SPECS/6.Build/example/repository-truth.md","content":"SOURCE_TRUTH provider adapter is the host boundary","selectionReason":"Direct source evidence shapes the plan."},{"id":"plan-duplicates","label":"Paired representations","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/6.Build/example/all-artefacts.md","content":"Repeated Markdown and JSON representations of the same planning evidence. ","repeat":90,"selectionReason":"Canonical files remain stored but need not all enter one model call."}]},
+  {"profile":"build-task","focus":"implement T-001","budgetTokens":230,"segments":[{"id":"build-task-contract","label":"Task contract","evidenceClass":"mandatory","priority":100,"sourcePath":"SPECS/6.Build/example/task-graph.json","content":"MANDATORY:BUILD TASK T-001 WRITE_SET src/runtime/context.mjs ALLOWED_COMMAND node test STOP_CONDITION authority drift","requiredMarkers":["MANDATORY:BUILD","TASK T-001","WRITE_SET","ALLOWED_COMMAND","STOP_CONDITION"],"selectionReason":"The complete task boundary is required."},{"id":"build-standard","label":"Applicable standard","evidenceClass":"mandatory","priority":95,"sourcePath":"SPECS/4.Constraints/standards/lifecycle-hook-safety.md","content":"STANDARD authority none HUMAN_GATE Build and Manual QA","requiredMarkers":["STANDARD","HUMAN_GATE"],"selectionReason":"Applicable standards and human gates are required."},{"id":"build-history","label":"Unchanged delivery history","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/6.Build/example/history.md","content":"Repeated unchanged delivery events and completed phase prose. ","repeat":100,"selectionReason":"Not needed for this task."}]},
+  {"profile":"fresh-context-review","focus":"review T-001","budgetTokens":230,"segments":[{"id":"review-contract","label":"Review contract","evidenceClass":"mandatory","priority":100,"sourcePath":"SPECS/6.Build/example/task-graph.json","content":"MANDATORY:REVIEW TESTS_FIRST DIFF WRITE_SET STOP_CONDITION VERDICT PASS_OR_FAIL","requiredMarkers":["MANDATORY:REVIEW","TESTS_FIRST","DIFF","WRITE_SET","VERDICT"],"selectionReason":"Fresh review obligations are required."},{"id":"review-standard","label":"Review standards","evidenceClass":"mandatory","priority":95,"sourcePath":"SPECS/4.Constraints/standards/lifecycle-hook-safety.md","content":"SECURITY privacy authority scope tests","requiredMarkers":["SECURITY","privacy","authority"],"selectionReason":"Review must cover standards and security."},{"id":"review-history","label":"Earlier conversation","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/6.Build/example/conversation.md","content":"Repeated earlier implementation conversation not needed by fresh review. ","repeat":100,"selectionReason":"Fresh review must not inherit unnecessary conversation."}]},
+  {"profile":"phase-contribution-review","focus":"review evidence contribution","budgetTokens":190,"segments":[{"id":"contribution-thread","label":"Shared evidence thread","evidenceClass":"mandatory","priority":100,"sourcePath":"SPECS/3.Evidence/contributions/example.json","content":"MANDATORY:CONTRIBUTION ATTRIBUTION source owner disagreement AUTHORITY_NONE","requiredMarkers":["MANDATORY:CONTRIBUTION","ATTRIBUTION","disagreement","AUTHORITY_NONE"],"selectionReason":"Attribution and unresolved disagreement are required."},{"id":"contribution-personas","label":"Active lenses","evidenceClass":"relevant","priority":60,"sourcePath":"SPECS/1.Scope/personas/index.json","content":"ACTIVE_PERSONAS business technical shared review","selectionReason":"Current lenses support challenge."},{"id":"contribution-history","label":"Prior revisions","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/3.Evidence/contributions/history.md","content":"Repeated superseded contribution revisions preserved canonically. ","repeat":90,"selectionReason":"Exact delta replaces replay of unchanged revisions."}]},
+  {"profile":"design-system-apply","focus":"prototype interaction and states","budgetTokens":240,"segments":[{"id":"design-authority","label":"Design authority boundary","evidenceClass":"mandatory","priority":110,"sourcePath":"Docs/human-approval-and-assurance-guide.md","content":"MANDATORY:DESIGN AUTHORITY_NONE cannot approve Build or Manual QA publish deploy or release","requiredMarkers":["MANDATORY:DESIGN","AUTHORITY_NONE","Manual QA","release"],"selectionReason":"Human design and delivery authority remains mandatory."},{"id":"design-required","label":"Required experience guidance","evidenceClass":"mandatory","priority":100,"sourcePath":"design-system/ewai.design-system.default/principles.md","content":"EXPERIENCE_PROMISE interaction content states accessibility intentional review","requiredMarkers":["EXPERIENCE_PROMISE","interaction","states","accessibility"],"selectionReason":"Required resolved design guidance must remain complete."},{"id":"design-focus","label":"Focus-matched component guidance","evidenceClass":"relevant","priority":60,"sourcePath":"design-system/org.example.product/components.md","content":"PROTOTYPE_FOCUS established components and responsive states","selectionReason":"The contribution matches this prototype surface."},{"id":"design-history","label":"Unrelated design history","evidenceClass":"optional","priority":5,"sourcePath":"SPECS/3.Evidence/design-history.md","content":"Repeated superseded visual exploration and prior prototype conversation. ","repeat":100,"selectionReason":"Historical exploration remains durable but outside this application."}]}
+]