Universal response and Decision Map front door

.github/workflows/ci.yml

@@ -17,6 +17,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
       - name: Set up Node
         uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:

.github/workflows/release-preflight.yml

@@ -29,6 +29,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
       - name: Set up Node
         uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:

README.md

@@ -1,46 +1,46 @@
 # Frontier Decision Engine
 
-**Bring a messy situation. Find the decision. Test choices when useful. Keep the final judgment human-owned.**
+**Bring the whole mess. FDE gives you something useful back, helps make uncertainty visible, and keeps the final decision human-owned.**
 
 [Open the live application](https://bridgenode7.com/frontier-decision-engine/)
 
 ![Frontier Decision Engine](docs/screenshots/reference/desktop-decision-frame.png)
 
-## Start with Decision Rescue
+## Start with one input
 
-Decision Rescue accepts ordinary language first. A visitor can put down what is happening, choose one useful next action, and build a Decision Frame without knowing decision-science terminology.
+The FDE front door starts with one free-form input. Put down a problem, question, worry, idea, decision, or a complete mess. FDE responds immediately with a provisional Decision Map showing only what can be safely organized from the words provided.
 
-FDE preserves what the person confirms and does not pretend browser JavaScript inferred evidence, probabilities, thresholds, scores, or a recommendation. A partial Decision Frame is a valid stopping point.
+The map is a draft, not a hidden machine decision. Possible signals stay possible until a person confirms them. When enough explicit structure exists, the map can continue into the deterministic Decision Lab. Otherwise, it offers a simple path to shape the missing pieces without pretending the missing information is known.
 
-Decision Rescue uses tab-scoped session storage so an accidental refresh can recover in-progress framing. It does not treat the original brain dump as model evidence. When a complete frame continues into the Decision Lab, existing browser-saved Lab work is never replaced without an explicit human choice.
+The experience is designed around a simple rule: **every meaningful input receives a useful response, and questions are used only when human judgment is actually needed to move the decision forward.**
 
-## What the Decision Lab does
+## Decision Map
 
-- Frames the decision, goals, choices, and plausible futures.
-- Evaluates the same choices across explicit goals and named conditions.
-- Shows unmet goals, ties, incomplete outcomes, and vulnerabilities.
-- Keeps final selection, rationale, and next action human-owned.
-- Exports a portable decision file and a readable decision summary.
+The map can show:
 
-Guided work supports 2–4 objectives, 2–3 choices, and 2–4 plausible futures. The minimum comparison is a real 2 × 2 × 2 model. FDE never fills missing analytical inputs on the person's behalf.
+- a possible decision;
+- choices mentioned explicitly;
+- things that may matter;
+- conditions that could change the answer; and
+- the smallest useful next step.
 
-The included ready example is a **synthetic critical-material source-qualification case**. It does not describe or certify a real supplier, material, capacity, compliance status, or investment.
+This is deliberately conservative. The browser does not call a remote AI service, retrieve outside facts, invent probabilities, or promote provisional text into verified evidence.
 
-## Privacy and authority
+## Decision Lab
 
-The application is static and browser-local. It has no backend, account system, analytics, telemetry, cookies, or default upload endpoint.
+When a person confirms enough structure, FDE can hand the work into its existing deterministic comparison engine. Guided work supports 2–4 objectives, 2–3 choices, and 2–4 plausible futures. The minimum comparison is a true 2 × 2 × 2 model.
 
-Browser storage is a convenience, not encrypted confidential storage. Do not enter information that requires an approved confidential or controlled-data environment.
+The comparison informs. A person decides.
 
-FDE provides decision support. It does not approve, authorize, certify, qualify, consent, or make an investment decision. The comparison informs; a person decides.
+## Synthetic reference
 
-## Run locally
+The repository includes a synthetic critical-material source-qualification case to demonstrate the formal Decision Lab without making claims about a real supplier, material, capacity, compliance status, or investment.
 
-```bash
-node scripts/run-python.mjs -m http.server 8000 --directory site
-```
+## Privacy and authority
+
+The application is static and browser-local. It has no backend, account system, analytics, telemetry, cookies, remote AI provider, or default upload endpoint. Session recovery and browser autosave are convenience features, not encrypted confidential storage.
 
-Open `http://localhost:8000`.
+FDE provides decision support. It does not approve, authorize, certify, qualify, consent, or make an investment decision.
 
 ## Verify
 
@@ -53,14 +53,14 @@ npm ci --ignore-scripts --no-audit --no-fund
 npm run check
 ```
 
-`npm run check` runs the repository's unit, version, integrity, browser, Decision Rescue, and release-closeout gates. Current generated counts and versions are recorded in [`project-facts.json`](project-facts.json).
+Generated release facts and current application identity are recorded in [`project-facts.json`](project-facts.json). The full verification gate is defined by the repository's `npm run check` command.
 
 ## Documentation
 
 - [Architecture](docs/ARCHITECTURE.md)
 - [Methodology](docs/METHODOLOGY.md)
 - [Privacy](docs/PRIVACY.md)
-- [Releases](docs/RELEASING.md)
+- [Releasing](docs/RELEASING.md)
 
 ## Project
 

docs/ARCHITECTURE.md

@@ -2,55 +2,54 @@
 
 Frontier Decision Engine is a static browser application served from `site/`. There is no backend or account service.
 
-## Runtime
+## Human-first runtime
 
-- Decision Rescue is the human-language front door.
-- Decision Lab is the structured six-stage comparison workflow.
-- The ranking engine is deterministic and runs in the browser.
-- Portable decision schemas remain versioned under `schemas/`.
-- Validation and release checks run from `scripts/` and GitHub Actions.
+The public root is a one-input response experience. A person can write a problem, question, worry, idea, decision, or incomplete thought without knowing decision-science vocabulary. FDE immediately returns a useful response and a provisional Decision Map.
 
-## Human-first entry
+The Decision Map can show:
 
-The root experience accepts bounded inert text and asks for the smallest useful human contribution next. It does not claim to understand arbitrary prose, retrieve external facts, infer evidence, assign probabilities, create scores, or recommend an action.
+- a possible decision;
+- choices mentioned explicitly;
+- things that may matter;
+- conditions that could change the answer; and
+- the most useful next step.
 
-A Decision Frame can remain incomplete and still be useful. Full comparison is available only after the person has confirmed a decision, at least two goals, two choices, and two plausible futures.
+Possible elements are not silently promoted into facts. The map is a draft until a person confirms the information that belongs in the formal decision model.
 
-Guided comparison supports:
+## Minimum necessary human contribution
 
-- 2–4 objectives
-- 2–3 strategies
-- 2–4 scenarios
+FDE follows this interaction rule:
 
-The ready example remains a larger synthetic reference case. Missing thresholds, scores, modifiers, critical flags, and evidence stay missing until a person supplies them.
+> Continue without bothering the person when the system can proceed safely; otherwise ask for the smallest human contribution that materially advances the decision.
 
-## Browser storage
+No normal input is treated as a dead end. Empty, vague, messy, ambiguous, and non-decision input receive a useful orientation response rather than an error-only state.
 
-Decision Rescue uses tab-scoped session storage for accidental-refresh recovery. The original starting context remains context only and is not scored or promoted into model evidence.
+## Formal Decision Lab
 
-Decision Lab uses bounded browser autosave for in-progress structured work. If a browser draft already exists, Decision Rescue does not replace it silently; replacement requires an explicit human choice.
+Once enough explicit structure exists and the person confirms the map, the confirmed information is handed into the existing deterministic Decision Lab. Guided comparison supports 2–4 objectives, 2–3 strategies, and 2–4 scenarios. The minimum comparison is a true 2 × 2 × 2 model.
 
-Browser storage is not encrypted confidential storage. Local files are processed in the browser and are not uploaded by the default application.
+The comparison core is isolated from the Map layer so UX changes do not silently alter ranking semantics. Missing analytical values are not fabricated.
 
-## Decision result
+## Epistemic boundaries
 
-The engine evaluates explicit human-supplied inputs across the same named futures. It preserves honest outcomes including:
+The public experience separates:
 
-- a unique leader under the tested model;
-- tied leaders;
-- no acceptable strategy under declared boundaries; and
-- insufficient data.
+1. **You said** — the original human input.
+2. **FDE organized** — provisional structure derived from safe, explicit textual patterns.
+3. **You confirmed** — information promoted into the formal model by a human.
+4. **FDE calculated** — deterministic output from confirmed model inputs.
+5. **You decided** — the human-owned choice, rationale, and next action.
 
-The result is advisory. A person selects the strategy and records the rationale and next action.
+The default runtime does not use a remote AI provider, retrieve external facts, infer evidence, assign probabilities, or make the final decision.
 
-## Compatibility
+## Browser storage
 
-Legacy completed decision schema `0.2.10` remains supported. Optional decision-semantics state uses schema `0.3.0`. The guided browser editor is intentionally bounded even though portable schemas may permit broader cases.
+The universal response experience uses bounded tab-scoped session storage for accidental-refresh recovery. Decision Lab uses bounded browser autosave for structured work. Browser storage is a convenience, not encrypted confidential storage.
 
-The deterministic ranking core is isolated from the human-entry layer so UX changes do not silently alter comparison semantics.
+## Privacy and security
 
-## Security and privacy boundaries
+The public application has no backend, account system, analytics, telemetry, cookies, remote AI provider, or default upload endpoint. User input is rendered as text, not executable markup. Local files remain in the browser unless the person explicitly downloads or shares them.
 
-The public runtime has no account system, analytics, telemetry, remote AI provider, or default upload endpoint. User-entered text is rendered as text rather than executable markup.
+## Long-term direction
 
-Generated visualizations and software calculations are not evidence. FDE does not provide legal approval, organizational authorization, certification, qualification, consent, or investment approval.
+The architecture intentionally leaves room for an optional assisted-understanding adapter and later Decision Memory without making either a dependency of the deterministic core. Any future semantic provider must produce provisional output that passes through the same human-confirmation boundary.

package.json

@@ -6,6 +6,7 @@
   "description": "Browser-local, human-governed decision support for choices under deep uncertainty.",
   "scripts": {
     "test": "node --test",
+    "test:universal": "node --test tests/universal-response.test.js",
     "facts": "node scripts/generate-project-facts.mjs",
     "facts:check": "node scripts/validate-project-facts.mjs",
     "validate": "node scripts/run-python.mjs scripts/validate_repository.py",
@@ -18,8 +19,6 @@
     "validate:version": "node scripts/run-python.mjs scripts/validate_version_integrity.py",
     "test:closeout": "node scripts/run-python.mjs scripts/browser_closeout_regressions.py"
   },
-  "engines": {
-    "node": ">=22"
-  },
+  "engines": { "node": ">=22" },
   "license": "Apache-2.0"
 }

project-facts.json

@@ -2,11 +2,10 @@
   "applicationVersion": "0.3.3",
   "schemaVersions": {
     "decision": "0.2.10",
-    "semanticDecision": "0.3.0",
-    "opvCase": "0.1.0"
+    "semanticDecision": "0.3.0"
   },
-  "testCount": 143,
-  "discoveredHashRouteLiteralCount": 6,
+  "testCount": 148,
+  "discoveredHashRouteLiteralCount": 7,
   "browserModes": [
     "desktop-light",
     "mobile-light",
@@ -16,11 +15,5 @@
     "reflow-400-equivalent",
     "forced-colors"
   ],
-  "manifestEntryCount": 35,
-  "retainedReferenceArtifactItemCounts": {
-    "profiles/phenomena/profile.json": 5,
-    "site/data/experiences.json": 41,
-    "site/data/morphology.json": 209,
-    "site/data/references.json": 53
-  }
+  "manifestEntryCount": 37
 }