# Change Log

All notable changes to the "Norn" extension will be documented in this file.

## [2.5.0] - 2026-05-27

### Added
- **Verbatim string literals** — added C#-style `@"..."` strings for Norn values, assertions, regex patterns, request URLs, sequence arguments/defaults, SQL arguments, schema paths, assertion messages, and `@data` values. Backslashes are literal, doubled quotes decode to a single quote, and `{{...}}` tokens inside verbatim strings are not interpolated.
- **Escape-aware highlighting** — `.norn` syntax highlighting now distinguishes decoded escapes from ordinary backslash text, including escaped quotes/backslashes in normal strings, regex escapes in `matches` patterns, doubled quotes in verbatim strings, and valid JSON escapes in request bodies.

### Changed
- **Regex assertion authoring** — `matches` patterns are now guided toward quoted string patterns, with `@"..."` recommended for regexes that contain many backslashes or literal quotes.

### Fixed
- **Quoted string handling** — escaped quotes and backslashes are decoded consistently across variables, request URLs, run arguments, sequence defaults, SQL arguments, `@data` values, `matchesSchema` paths, and assertion messages while preserving unknown escapes such as `\A` as literal text.
- **Editor assistance with verbatim strings** — diagnostics, inlay hints, and hover providers no longer treat `{{...}}` inside verbatim strings as interpolated Norn variables.
- **Sequence tag diagnostics** — `@smoke`, `@team(...)`, and other sequence tags are recognized by editor diagnostics again instead of being reported as unknown statements.
- **Failure output expected values** — CLI, HTML/JUnit reports, and the response panel now prefer the resolved expected value for failed assertions instead of falling back to the raw expression text.
- **Test Explorer environment resolution** — Test Explorer now uses the only available `.nornenv` environment for isolated single-env fixtures when no active environment has been selected, fixing nested regression cases such as encrypted env imports.

### Testing
- **Editor diagnostics automation** — added an Extension Host suite that discovers `tests/EditorDiagnostics/valid` and `tests/EditorDiagnostics/negative`, keeping clean fixtures at zero diagnostics and intentional error fixtures at exact expected counts.
- **Runtime negative automation** — converted former manual runtime error cases into `tests/RuntimeNegative` scenarios that assert CLI exit codes and stable error guidance.
- **Test Explorer automation** — added Extension Host checks for Test Explorer fixture exclusion patterns and single-env `.nornenv` resolution.
- **Pre-release verification** — added `npm run test:prerelease` and updated release verification to run Extension Host automation plus the local CLI Regression suite.
- **Test suite cleanup** — moved reusable `.nornenv` import and contract fixtures into Regression, moved API coverage fixtures into `tests/ApiCoverage`, and removed stale scratch/demo test folders.

## [2.4.0] - 2026-05-25

### Added
- **Per-folder and persisted active environment** — the active env is now tracked per `.nornenv` file (keyed by absolute path) and persisted to the workspace memento. In monorepos each folder remembers its own selection, and selections survive VS Code restart. The status bar shows the env for the current editor's nearest `.nornenv`. Stale entries (deleted `.nornenv` files) are pruned on load.
- **Region-pattern refactor** — when a `.nornenv` contains a flat `[env:STAGE_REGION]` matrix (e.g. `dev_us`, `dev_uk`, `prod_us`, `prod_uk`), the top of the file shows a "Refactor N envs into S+R templates" CodeLens. Clicking it classifies each variable by axis (stage / region / leaf-specific) and lifts shared values into `[template:STAGE]` + `[template:REGION]` blocks, leaving only true leaf-specific overrides in the env sections. Missing values and `connectionString` declarations stay leaf-specific, per-declaration `secret` keywords are preserved, and the same generator is available in the CLI via `--refactor-region-pattern` / `--write`. The VS Code refactor is one `WorkspaceEdit` so a single Cmd+Z reverses it.

## [2.3.0] - 2026-05-20

### Added
- **Inlay hints + hover across every Norn file type**:
  - `.norn`: every `{{name}}` / `{{$env.name}}` token resolves under the active env, with three-scope precedence — sequence-local `var` declarations ← file-level `var` declarations ← active env's effective vars. Runtime values (`$1.body.x`, `run X()`, request captures) are intentionally not rendered inline; hover narrates them with source line.
  - `.nornapi`: every `{{...}}` token in headers groups and endpoint definitions resolves under the active env.
  - `.nornsql`: the `connection NAME` line shows the resolved `NAME_connectionString` from `.nornenv` (masked if a `secret connectionString`). Hover narrates the source. Any `{{...}}` in SQL bodies is handled for parity.
  - Resolution and reference parsing live in `src/inlayHintResolver.ts` so every provider behaves identically.
- **`.nornenv` Templates And Extends (Extension + CLI)**:
  - Added `[template:NAME]` sections and multi-parent template `extends` on `[env:...]` / `[template:...]` headers.
  - Resolved env values as `common <- template1 <- template2 <- self`; templates compose into envs but are not selectable in the status bar or CLI `-e`.
  - Added `.nornenv` Activate/Deactivate and Peek inherited CodeLens actions, folding ranges, smart header decorations, hover resolution chains, inlay hints for `{{...}}`, and inherited-variable completions.
  - Added diagnostics for unknown extends parents, invalid env parents, extends cycles, out-of-scope cross-section references, and typo-like override names.

### Fixed
- Endpoint path arguments now keep bare `.nornenv` names as literal path values unless the reference is explicit (`{{name}}` / `{{$env.name}}`), while declared file/sequence variables still resolve in endpoint calls.

## [2.2.0] - 2026-05-09

### Added
- **Starter Catalogue (VS Code)**:
  - Added a Project Setup starter catalogue in the sidebar with a Back button and readable stacked sample titles/descriptions.
  - Added Explorer folder context-menu parity for opening the same starter catalogue.
  - Added self-contained generated starter folders for simple requests, scripts plus JSON data, a runnable SQL demo, a real SQL connection starter, and an advanced end-to-end flow with `.nornenv`, `.nornapi`, helper sequences, tests, and schema contracts.

### Fixed
- **Environment Template Diagnostics (VS Code)**:
  - Allowed `.nornenv` variables such as `{{primaryUserId}}` and `{{postTitle}}` in assertion and condition expression contexts when those values are intentionally resolved from the environment file.
  - Kept the bare-variable diagnostic for local, file, and sequence variables so runtime values are still read directly in expressions.

- **Sequence Argument Resolution (Extension + CLI)**:
  - Resolved bare variable paths such as `user.id` and array-indexed paths such as `todosResponse.body[0]` before binding `run SomeSequence(...)` parameters.
  - Fixed advanced schema-validation flows where unresolved literal argument text could produce empty responses and misleading `matchesSchema` object errors.

### Changed
- **Website Docs and Skills**:
  - Updated website VS Code docs for the starter catalogue, self-contained samples, SQL starter split, advanced flow, and Explorer context-menu behavior.
  - Added starter-catalog maintenance guidance and updated value-resolution guidance for sequence argument binding.

## [2.1.0] - 2026-05-08

### Improved
- **Contract Validation Results (Extension + CLI)**:
  - Replaced raw `matchesSchema` assertion text in CLI, Test Explorer, and Response Panel output with schema names and property/path-level validation counts.
  - Added richer Response Panel contract cards with validation pills, validated-property details, concise issue summaries, warning-only styling, and direct `View Contract Details` navigation.
  - Added a validated-properties tab and `Back to Results` navigation to Contract Details.

- **`.nornapi` Authoring (VS Code)**:
  - Added diagnostics for unresolved endpoint variables such as `{{baseUrl}}` when the nearest `.nornenv` file does not define them.
  - Added active-environment diagnostics for `{{$env.name}}` references in endpoint URLs and header groups.
  - Updated `.nornapi` syntax highlighting so `{{...}}` interpolation matches `.norn` coloring while path parameters such as `{id}` stay distinct.

### Fixed
- **Response Panel Stability**:
  - Fixed contract-result rendering paths that could leave the sequence response panel stuck on the initial spinner or after returning from Contract Details.
  - Preserved the completed result header styling when rebuilding result pages for contract navigation.

- **Contract Validation Noise**:
  - Suppressed Ajv warnings for OpenAPI numeric formats such as `int32`, `int64`, `float`, and `double`.
  - Cleaned up Contract Details display for root-level and missing-property errors so it no longer shows placeholder paths or fake missing actual values.
  - Removed the extension activation debug log from the VS Code debug console.

### Changed
- **Website Docs**:
  - Updated website documentation and the website `.nornapi` grammar copy for the new contract-result and authoring behavior.

## [2.0.1] - 2026-04-30

### Changed
- **Norn Icon Refresh**:
  - Updated the extension package icon to match the Norn API/network mark used on the website and Activity Bar.
  - Replaced the stylized `.norn` file icon with a teal-blue test tube icon.
  - Recolored `.nornapi`, `.nornsql`, and `.nornenv` file icons to use the Norn teal-blue brand palette.

## [2.0.0] - 2026-04-29

### Added
- **SQL Environment Templates (Extension + CLI)**:
  - Added `.nornenv` template interpolation for SQL connection/profile values using `{{name}}` and `{{$env.name}}` references.
  - Resolved SQL connection templates from the active merged `.nornenv`, including imported files and selected `[env:...]` overrides.
  - Added CLI redaction support for resolved secret-derived template values.
  - Added regression coverage for imported `.nornenv` template variables and live SQL Server execution.

### Improved
- **`.nornenv` Authoring (VS Code)**:
  - Added template-variable IntelliSense inside `.nornenv` values, including single-brace completion to `{{name}}`.
  - Added syntax highlighting for `{{...}}` template references inside environment values and connection strings.
  - Added diagnostics for unsupported, missing, and invalid-scope `.nornenv` template references.

### Changed
- **Breaking Config Consolidation**:
  - Replaced separate SQL and MCP project config files with a single `norn.config.json` file.
  - Moved SQL connection aliases and custom SQL adapters under `sql.connections` and `sql.adapters`.
  - Moved MCP server aliases under `mcp.servers` and updated schema-backed IntelliSense for the unified config file.

### Fixed
- **SQL Connection Safety**:
  - Rejected invalid environment-to-environment SQL connection template references before adapter invocation.
  - Masked the SQL environment-template regression fixture output so sample secrets are not printed in CLI logs.

## [1.13.1] - 2026-04-28

### Improved
- **MCP Tool Discovery Display (VS Code)**:
  - Replaced raw JSON rendering for `run mcp list` steps in the response panel with a readable tool directory showing names, descriptions, parameter metadata, required markers, and structured-output badges.
  - Kept the underlying captured `tools` value unchanged for assertions, runtime variables, reports, and CLI parity.

- **Variable IntelliSense (VS Code)**:
  - Added sequence-local variables and sequence parameters to `{{...}}` interpolation completions, including single-brace partial typing such as `{s`.
  - Added completion fallback for `.nornenv` variable names when no active environment is selected.
  - Fixed completion replacement ranges so selected interpolation suggestions apply on the current cursor line.

### Fixed
- **Norn API IntelliSense (VS Code)**:
  - Fixed `.nornapi` block detection so top-level `headers` suggestions appear after `end endpoints`, while header-name suggestions still work inside `headers ... end headers` blocks.

## [1.13.0] - 2026-04-26

### Added
- **Cached API Response IntelliSense (VS Code)**:
  - Added sampled response-shape caching in `.norn-cache/api-response-intellisense.json` after successful `Send Request` and `Run Sequence` runs.
  - Added cached property completions for `$N.body.` and captured response variables such as `user.body.`, including nested object paths.
  - Added source-aware and environment-aware response-shape reuse for later body-path authoring in the editor.

### Improved
- **Response Authoring and Diagnostics (VS Code)**:
  - Improved response-property completions so partial property names filter correctly for captured responses, body paths, and common headers.
  - Added undefined-base-variable diagnostics for bare `assert`, `if`, `return`, `print`, and property-assignment expressions without flagging runtime-shaped JSON paths when the base variable exists.
  - Added clearer print diagnostics when a plain word is interpreted as an undefined variable instead of a quoted string literal.

### Changed
- **Website Docs**:
  - Added website docs for cached response-body IntelliSense, cache privacy boundaries, and the VS Code sequence authoring workflow.

## [1.12.0] - 2026-04-20

### Added
- **MCP Tool Arguments (Extension + CLI)**:
  - Added positional MCP tool arguments for `run mcp call <alias> <tool>(...)`, bound in tool-schema order alongside existing named arguments.
  - Added schema-aware MCP tool resolution before tool execution so required, duplicate, and unknown parameter checks use the server's declared input schema consistently.
  - Added regression coverage for positional and mixed MCP argument calls in both the fake MCP fixtures and the docker-backed MCP regression.

### Improved
- **MCP Editor Authoring (VS Code)**:
  - Added config-scoped `.norn-cache` persistence for listed MCP tool metadata so tool-name completions and parameter hints work from cached discovery data.
  - Added compact MCP parameter hints with schema-backed descriptions for the active parameter and cleaner tool insertion with `()`.
  - Suppressed unrelated bare-variable suggestions while typing inside MCP tool argument lists.

### Fixed
- **MCP Diagnostics and Fixture Metadata**:
  - Fixed diagnostics so positional MCP tool arguments are not treated like duplicate named arguments.
  - Enriched the fake MCP regression tool schemas with parameter descriptions so cached hint text stays meaningful during local testing.

## [1.11.0] - 2026-04-19

### Added
- **Deterministic MCP Tools (Extension + CLI)**:
  - Added `norn.mcp.json` project config with nearest-file resolution, stdio and HTTP transports, and shared alias-based runtime behavior.
  - Added `run mcp list <alias>` and `run mcp call <alias> <tool>(name: value)` with variable capture support in both VS Code and the CLI.
  - Added deterministic MCP session reuse per resolved config file plus alias for the lifetime of a sequence run, including nested and imported sequences.
  - Added MCP tool output-schema validation, paginated `tools/list` draining, dedicated CLI/report output, response-panel rendering, and regression fixtures for stdio and HTTP MCP servers.

### Improved
- **Project Setup UX (VS Code)**:
  - Added `Create SQL starter files` and `Create MCP starter config` commands to the Norn sidebar and Explorer folder context menu.
  - Added starter `norn.mcp.json` content with inline `_comment` guidance fields for alias usage, local vs remote servers, and optional config fields.
  - Added MCP-specific response panel styling so MCP steps no longer reuse SQL visuals.

### Fixed
- **Array Count Path Access**:
  - Fixed structured path resolution so array values can be asserted with `.count` consistently across captured variables, response-body paths, and MCP tool lists.

### Changed
- **Website Docs**:
  - Added MCP documentation to the website, including config setup, `run mcp` usage, CLI parity notes, and VS Code project-setup flows.

## [1.10.6] - 2026-03-28

### Fixed
- **Structured Variable Storage**:
  - Kept structured runtime values as real objects instead of JSON strings so the debugger, assertions, and path access all see the same types.
  - Preserved compatibility for existing string-backed values when resolving paths.

### Changed
- **Docs**:
  - Updated the advanced website docs to note that structured values stay as objects in memory.

## [1.10.5] - 2026-03-28

### Improved
- **URL-Encoded Request Bodies (Extension + CLI)**:
  - Added stricter shared validation for `application/x-www-form-urlencoded` request bodies so malformed lines now fail fast with clear preflight errors in both the editor and CLI.
  - Added support for single-line ampersand-delimited form bodies such as `key1=value1&key2=value2`.
  - Preserved raw-request header-group workflows by stripping standalone header-group lines from the request body before validation and send.

### Fixed
- **Imported Parameterized Sequences**:
  - Fixed `.norn` import resolution so imported helper sequences keep their parameter lists and can be invoked correctly from other files.

- **Form Body Syntax Highlighting**:
  - Fixed `.norn` syntax coloring so URL-encoded body lines are highlighted correctly after inline headers in raw request blocks.

## [1.10.4] - 2026-03-21

### Improved
- **Request Failure Response Panel**:
  - Refreshed request-failure views with a clearer error summary, request context bar, structured issue cards, and common-cause guidance.

### Changed
- **Regression + Contributor Tooling**:
  - Standardized regression test docs and scripts around `node ./dist/cli.js`, added `npm run validate:skills`, and refreshed bundled skill/demo assets.

### Fixed
- **SQL Server Live Regression Fixture**:
  - Made the SQL Server Docker regression setup safe to rerun during repeated local release verification.

## [1.10.2] - 2026-03-15

### Fixed
- **Sequence Return + Response Panel UX**:
  - Fixed `var result = run SomeSequence` so single-value returns can capture literal values like `return "Bar"` instead of resolving to empty output.
  - Fixed streaming/final response panel step timers so print/SQL rows show per-step duration instead of elapsed-from-start totals.
  - Fixed the streaming step counter so hidden `wait` steps no longer inflate the top-bar step total.
  - Fixed `.norn` syntax highlighting so quoted string literals after `return` use normal string coloring.

- **Request Parsing + CLI Error Output**:
  - Fixed request parsing to stop bodies at the next Norn block boundary, preventing later named requests or sequence declarations from leaking into request bodies.
  - Fixed CLI text and HTML reports to preserve multiline request/sequence error details instead of collapsing them into single-line output.

- **API Coverage + Import UX**:
  - Fixed API coverage to follow status assertions on captured request variables and named requests that call `.nornapi` endpoints.
  - Fixed the OpenAPI import section picker so selecting `All` stays mutually exclusive with individual section selections.

## [1.7.0] - 2026-03-07

### Added
- **Explicit Environment Lookup (Extension + CLI)**:
  - Added `{{$env.name}}` so tests, sequences, endpoints, header groups, and interpolated strings can read directly from the active environment even when a file variable, local variable, or sequence parameter uses the same name.
  - Added IntelliSense for the `$env` namespace and environment variable suggestions after typing `{{$env.`.
  - Added diagnostics for invalid `{{$env...}}` references and warnings when local/file/parameter variables shadow environment variables.

### Fixed
- **Assertion String Literal Escaping**:
  - Fixed escaped quotes in assertion string literals and quoted `var` expressions so values like `\"{orderId}\"` compare correctly instead of failing with visually identical expected/actual output.

- **Parameterized Test Snippet UX**:
  - Updated `@data` completion to insert `data()` with the cursor inside the parentheses instead of placeholder values.

- **Decorator Syntax Highlighting**:
  - Fixed `.norn` syntax coloring so decorator lines such as `@data(...)` keep their highlighting when they follow request blocks like `DELETE ...`.

## [1.6.2] - 2026-03-07

### Fixed
- **`.nornenv` IntelliSense and Diagnostics**:
  - Fixed `[env:` completion in `.nornenv` files so accepting the suggestion after typing `[` no longer inserts `[[env:`.
  - Fixed `.nornenv` diagnostics and syntax highlighting so secret names that start with `var` (for example `secret varnaCityApiKey = ...`) are no longer flagged as invalid.

- **Encrypted Secret UX (Extension + CLI)**:
  - Fixed secret-key cache placement so new secret-key caches are created in the project root `.norn-cache` instead of nested folders beside individual `.nornenv` files.
  - Reused an existing secret-key cache when one is already present in the project, avoiding duplicate `.norn-cache` folders.
  - Fixed Windows CRLF handling for `.nornenv` secret parsing so the `Encrypt Secret` CodeLens remains available reliably on Windows and secret rewrites preserve the file's original line endings.

## [1.6.1] - 2026-03-04

### Fixed
- **Parameterized Debug Launch (VS Code)**:
  - Fixed `Debug Sequence` launch from editor/CodeLens so `@data` / `@theory` case arguments are passed into the debug session.
  - Added case selection prompt when multiple parameterized cases exist, so a single concrete case is debugged without unresolved placeholders.

- **CLI `--sequence` Parameterized Execution**:
  - Fixed `node ./dist/cli.js <file> -s <sequence>` to execute `@data` / `@theory` cases (instead of ignoring case args and failing on unresolved variables).
  - Aligned `--sequence` behavior with full test execution mode for parameterized sequences.

## [1.6.0] - 2026-03-04

### Added
- **Native VS Code Debugger for `.norn` Sequences (v1)**:
  - Added Debug Adapter Protocol integration for debug type `norn`.
  - Added line breakpoints in `.norn` files, including imported sequence sources.
  - Added stepping controls: continue, pause, step over, step into sequence calls, step out, and stop.
  - Added debugger variable scopes for runtime variables and response history (`$1`, `$2`, ...).
  - Added launch support via `launch.json` with `file`, `sequence`, optional `env`, and `stopOnEntry`.

- **Debugger Entry Points**:
  - Added `Debug Sequence` command (`norn.debugSequence`).
  - Added `▷ Debug Sequence` CodeLens on runnable sequences.
  - Added Testing sidebar `Debug Tests` profile (single-target debug in v1).

### Improved
- **Debugger Runtime Behavior**:
  - Added breakpoint line verification/auto-adjust to nearest executable step in the same sequence.
  - Added failure-stop behavior for request/assertion failures before session termination.
  - Added source/line mapping across root and imported sequence files for call stack and stepping.
  - Added smart launch default for `stopOnEntry` in command/test-driven debug starts (disabled when breakpoints already exist).

- **Documentation and Skills**:
  - Added README debugger usage and `launch.json` example.
  - Added debugger integration skill docs under `.github/skills/norn-debugger-integration`.
  - Documented debugger as a VS Code-only v1 exception to CLI feature parity policy.

## [1.5.4] - 2026-03-02

### Improved
- **Norn Cache Git Ignore Behavior**:
  - Stopped modifying the repository root `.gitignore` when secret keys are cached.
  - Added local cache-level ignore behavior by writing `.norn-cache/.gitignore` with `*`.
  - Keeps `.norn-cache` contents out of Git without mutating user-managed root ignore files.

## [1.5.3] - 2026-03-02

### Added
- **Native Encrypted `.nornenv` Secrets (Extension + CLI)**:
  - Added encrypted secret format support: `secret name = ENC[NORN_AGE_V1:kid=<id>:<payload>]`.
  - Added automatic secret decryption during environment resolution for both VS Code execution and CLI runs.
  - Added `norn secrets` command group: `keygen`, `import-key`, `encrypt`, `rotate`, `rekey`, `audit`, `keys`, `forget`.
  - Added `.nornenv` CodeLens actions: `Encrypt Secret`, `View Decrypted`, `Rotate Secret`, `Delete Secret`.
  - Added encrypted environment regression coverage with chained `.nornenv` imports.

- **TLS Certificate Verification Toggle (Extension + CLI)**:
  - Added VS Code setting `norn.security.verifyTlsCertificates` (default `true`) to control TLS certificate verification for HTTPS requests and Swagger/OpenAPI fetches.
  - Added CLI flag `--insecure` to disable TLS certificate verification for local/self-signed development environments.
  - Wired shared runtime TLS behavior so extension request execution, CLI execution, Swagger imports, schema extraction, coverage refresh, and chat Swagger fetches use the same verification mode.

### Improved
- **Secrets UX and Safety**:
  - Added known `kid` picker so users can select previously used key IDs instead of typing each time.
  - Added first-time encryption flow to generate a new shared key once (or use an existing key from vault), then cache locally.
  - Improved decrypted secret display to a secure modal flow with masked preview, explicit reveal, and copy action (no plaintext editor tab).
  - Added best-effort auto-ignore for `.norn-cache/` in repo `.gitignore` when secret keys are first cached.

## [1.5.2] - 2026-02-28

### Improved
- **Premium Aurora UI Design**:
  - Updated Home sidebar with aurora gradient welcome card, styled file type pills, and resource links.
  - Updated response panels with aurora-styled headers, status badges, and tabbed navigation.
  - Updated assertion failure details with gradient backgrounds and styled error highlighting.
  - Updated API Coverage panel with gradient headers, progress bars, and styled endpoint sections.
  - Updated Contract Report panel with gradient summary cards and styled issue lists.
  - Added consistent 3D-style colored icons for print, script, timer, and sequence group steps.

## [1.5.1] - 2026-02-28

### Improved
- **Path IntelliSense (Import + Scripts)**:
  - Added relative path completions for `import` statements and script commands (`run bash`, `run powershell`, `run js`, `run readJson`) in `.norn` files.
  - Suggestions now resolve from the active file directory and continue navigation on `/`.
  - File suggestions prioritize relevant extensions by context (for example `.norn`/`.nornapi` for imports, `.ps1` for PowerShell, `.js` for JS).

- **.nornenv IntelliSense**:
  - Added relative import path IntelliSense in `.nornenv` files.
  - `.nornenv` is now visible in path suggestions by default, even when hidden files are not explicitly prefixed.

- **Suggestion Icon Consistency**:
  - Path completion entries now consistently use file/folder icons in suggest lists to avoid iconless entries.

## [1.5.0] - 2026-02-26

### Added
- **Postman Import (VS Code, v1)**:
  - Added a new `Norn` Activity Bar sidebar entry with `Postman Imports` actions for collection and environment JSON imports.
  - Added a review-before-write import wizard flow (`Select -> Review -> Result`) for safer migration into Norn files.
  - Added Postman import generation for `.nornapi`, `.norn`, and `.nornenv` outputs with warnings/blockers surfaced before writes.
  - Added Postman import test fixtures under `tests/PostmanImport/`.

### Improved
- **Postman Import Conversion Output**:
  - Collection-level Postman variables now generate into top-level global entries in `.nornenv` instead of being duplicated in each `.norn` file.
  - Path/query placeholders are converted into endpoint parameters while base URL placeholders remain environment-driven variables.
  - Environment imports now append into an existing `.nornenv` (with warnings for duplicate env names) instead of blocking import.

## [1.4.5] - 2026-02-24

### Fixed
- **Diagnostics False Positive (JSON Property Assignment)**:
  - Fixed editor squiggles on valid JSON property assignments with array indexing, for example `config.users[0].name = "Updated Alice"`.

## [1.4.4] - 2026-02-24

### Improved
- **Error UX (Extension + CLI)**:
  - Added structured, more actionable request/sequence error messages with environment-aware hints.
  - Improved preflight validation so unresolved variables and invalid URLs are caught before request execution.
  - Standardized error formatting across extension response panel and CLI output.

- **Response Panel Error Readability**:
  - Sequence errors/warnings now render as timeline entries (same visual style as execution steps) and appear at the end of the run.
  - Error details are grouped into clearer sections with primary fields surfaced first.

- **Diagnostics Coverage and Persistence**:
  - Expanded `.norn` editor diagnostics for malformed statements and invalid command combinations.
  - Added workspace-wide diagnostic refresh so Explorer error badges persist after files are closed.

### Fixed
- **Diagnostics False Positives**:
  - Fixed false squiggles for valid request body variable lines (for example `payload` used as a request body).
  - Fixed false squiggles for endpoint calls with parameters (for example `GET MultiParam(hello, world)` and named args).
  - Fixed false squiggles for commented-out empty variable references (`{{}}`) in comment lines.

- **Preflight Validation Regression**:
  - Fixed request preflight validation incorrectly blocking some `GET`/`HEAD` requests due to unresolved placeholders detected in parsed body content.

## [1.4.3] - 2026-02-22

### Improved
- **@norn Chat Context Efficiency**:
  - Chat participant now sends heavyweight grounding context only on the first turn of a conversation.
  - Follow-up turns reuse conversation history without re-injecting full system prompt and active-file payload each message.
  - Reduces token usage and improves chat responsiveness in multi-turn sessions.

## [1.4.2] - 2026-02-21

### Fixed
- **API Coverage (Template Path Segments)**:
  - Fixed endpoint path normalization for coverage when `.nornapi` endpoint URLs contain multiple leading template variables, e.g. `{{baseUrl}}/{{version}}/pet/{petId}`.
  - Prevents false 0% coverage in workspace samples where endpoint URLs are composed from `baseUrl` + `version` path segments.

### Added
- **Regression Fixture (Coverage Scope)**:
  - Added `tests/ApiCoverage/coverage-scope/template-version.nornapi` and `tests/ApiCoverage/coverage-scope/template-version-covered.norn` to lock in template-path coverage behavior.

## [1.4.1] - 2026-02-21

### Changed
- Updated logo icon

## [1.4.0] - 2026-02-21

### Added
- **@norn Copilot Chat Participant**:
  - New `@norn` chat participant for GitHub Copilot Chat integration.
  - Slash commands: `/generate` (create Norn requests/sequences), `/explain` (understand existing code), `/convert` (cURL/HTTP to Norn).
  - Inline LLM tools for file editing, workspace reading, Swagger parsing, diagnostics inspection, and test execution.
  - `norn_runTest` tool allows the AI to run test sequences and report results directly in chat.
  - `norn_applyEdit` and `norn_createFile` tools let the AI modify or create `.norn`, `.nornapi`, and `.nornenv` files.
  - `norn_readSwagger` tool parses OpenAPI specs to help generate tests for APIs.
  - `norn_getDiagnostics` tool inspects current errors/warnings in Norn files.
  - Comprehensive system prompt teaches the AI the full Norn language specification.
  - Gracefully skipped when GitHub Copilot is not installed.

### Improved
- **Test Execution (Chat Tools)**:
  - Environment resolution for `norn_runTest` now auto-selects the first available environment when none is active.
  - Test results in chat now display the environment used and available alternatives.
  - Clear error messages when environment-specific variables fail to resolve.

### Fixed
- **Chat Participant Robustness**:
  - Added cancellation token checks to prevent runaway tool-calling loops.
  - Ambiguous `searchText` in `norn_applyEdit` replace action now returns an error instead of silently replacing the first match.
  - Glob pattern normalization in `norn_readWorkspaceFile` prevents double `**/` prefixes.

## [1.3.21] - 2026-02-17

### Fixed
- **API Coverage Scope (Swagger CodeLens/Panel)**:
  - Coverage for a `.nornapi` file now only includes `.norn` tests in that file's directory and descendants.
  - Parent/sibling directories are no longer counted when opening coverage from a specific `.nornapi` file.
  - `run SequenceName` resolution for coverage is now scoped by directory tree to avoid cross-folder name collisions.
- **Endpoint Path Mapping for Coverage**:
  - Fixed coverage endpoint mapping when `.nornapi` endpoints use variable-prefixed URLs such as `{{baseUrl}}/path`.
  - This prevents false 0% coverage in isolated folder setups.
- **Coverage UI Accuracy**:
  - Swagger coverage CodeLens now shows a stable `Show Coverage` action instead of stale global percentages.
  - Coverage status bar now behaves as a context-aware action button and no longer shows drifting percentage values.
  - Status bar click target now follows the active `.nornapi` editor context.
- **Diagnostics – Invalid JSON Body Shape**:
  - Added `.norn` diagnostic for JSON-like request body properties missing surrounding `{ }` in `POST`/`PUT`/`PATCH` requests.
  - Example now flagged: property lines like `"username": "value"` directly under a request without an object wrapper.
  - Diagnostic correctly skips form-style bodies when `Content-Type` is `application/x-www-form-urlencoded` or `multipart/form-data` (inline header or header group).

## [1.3.20] - 2026-02-15

### Fixed
- **API Coverage (Run Sequences)**:
  - Status assertions written after `run` calls are now applied to the returned request from the called sequence.
  - Coverage now correctly reflects patterns like `var user = run GetUser` followed by `assert user.status == 200`.
- **Coverage Assertion Scanning**:
  - Improved scan boundaries so assertions do not leak across `var ... = run ...` step boundaries.
- **Compile Compatibility (Node 16)**:
  - Added compatibility shims in ESLint config for `structuredClone` and `AbortSignal.throwIfAborted` so `npm run compile` succeeds on older Node runtimes.

## [1.3.19] - 2026-02-15

### Added
- **Swagger Request Body IntelliSense (Endpoint Calls)**:
  - Added request body template insertion for `POST`/`PUT`/`PATCH` endpoint calls backed by Swagger metadata.
  - Added inline JSON key suggestions inside request bodies using cached Swagger request schemas.
  - Added persistent request-schema cache in `.norn-cache/swagger-body-intellisense.json`.

### Improved
- **Swagger Schema Cache Availability**:
  - Extension now warms request-body schema cache from `.nornapi` `swagger` URLs on startup and on `.nornapi` save.

### Fixed
- **Request Body Completions**:
  - Fixed endpoint-to-swagger path mapping when endpoint URLs use variable prefixes like `{{baseUrl}}/...`.
  - Fixed body-start completion filtering so template suggestions appear reliably when typing `{` / `[`.
  - Fixed template insertion indentation and fallback behavior when schema has no required fields.

## [1.3.18] - 2026-02-15

### Improved
- **Environment Resolution (Extension + CLI)**: `.nornenv` resolution is now file-aware and uses the closest ancestor file.
  - VS Code execution paths now resolve env variables from the current document path.
  - CLI directory runs now resolve environments per test file path (including nested folders).
  - CodeLens and environment status now reflect the active editor/file context.

### Fixed
- **IntelliSense in Request Bodies**:
  - Header completions are suppressed when starting JSON body lines (`{` or `[`).
  - Header suggestions remain available for non-body lines, including raw URL requests (e.g., `POST "https://..."`).
- **Syntax Highlighting**:
  - Fixed header coloring after endpoint calls where header-group token matching could break on `Content-Type`.
  - Improved assert string highlighting with variable interpolation inside quoted strings.

### Added
- **Regression Coverage**:
  - Added env-resolution regression tests for parent vs nested `.nornenv` precedence.

## [1.3.17] - 2026-02-14

### Fixed
- **Import Resolution**: Improved duplicate import handling while preserving circular import detection
  - Re-importing already loaded files is now treated as a no-op instead of a false circular error
  - True cycles are still detected via active import stack tracking
- **Sequence Var-Request Parsing**: Fixed multi-line `var x = METHOD ...` request collection
  - Headers and JSON/form bodies are now preserved until the next real command boundary
  - Body-only shorthand continues to parse correctly
- **Syntax Highlighting**: Improved `var` request URL/header/body highlighting in `.norn` files
  - Better distinction between endpoint captures and raw URL captures
  - Header groups and body lines now color consistently in URL-style var requests

## [1.3.16] - 2026-02-13

### Fixed
- **IntelliSense**: Additional completion fixes and reliability improvements

## [1.3.15] - 2026-02-13

### Fixed
- **IntelliSense**: Applied fixes to improve completion reliability and keyword suggestions
- **Regression Stability**: Updated Petstore contract schema for `findByStatus` to handle responses where `photoUrls` may be omitted

## [1.3.14] - 2026-02-12

### Fixed
- **Assertion Equality for Objects/Arrays**: `==` and `!=` now perform deep structural comparison for objects and arrays
  - `assert $1.body.args == {}` now correctly passes for empty-object payloads
  - Scalar comparisons retain existing coercion behavior
- **Regression Stability**: Updated empty-literals regression coverage for current `httpbin` behavior
  - `files` in `GET /get` may be omitted, so the test now asserts `!exists`

## [1.3.13] - 2026-02-10

### Fixed
- **Script Variable Resolution**: Fixed `print` showing raw command text instead of script output
  - `extractVariables` now skips runtime-computed values (`var x = run ...`, `var x = $1...`, `var x = METHOD url`)
  - Variables are only pre-populated for static assignments, not scripts/captures
- **Test Explorer Script Paths**: Fixed script path resolution when running tests through Test Explorer
  - Scripts in imported sequences now resolve relative to the imported file, not the importing file
  - Added `sequenceSources` parameter to Test Explorer execution path

## [1.3.12] - 2026-02-10

### Fixed
- **Variable Request with Form Body**: Fixed `var x = POST EndpointName HeaderGroup` not passing URL-encoded body
  - Body lines following the var request command are now correctly collected and sent
  - Example: `var result = POST PostFormData FormData` followed by `key=value` lines now works

## [1.3.11] - 2026-02-09

### Fixed
- **Syntax Highlighting**: Fixed header value colors in sequences
  - `Content-Type: application/json` now correctly colors the entire value
  - `/json` part no longer incorrectly highlighted as URL
- **Syntax Highlighting**: Fixed numbers in variable names being highlighted separately
  - `item3.status` now shows as single variable color instead of `item` + `3` in different colors
  - Added proper variable pattern matching in assert statements

## [1.3.10] - 2026-02-09

### Fixed
- **Type Preservation in Property Assignments**: Bare variables now preserve their original type
  - `payload.userId = myNumericVar` keeps the number type instead of converting to string
  - Script outputs that are valid JSON (numbers, booleans, objects) are now properly typed
  - Use `payload.field = "{{var}}"` to force string type when needed

## [1.3.9] - 2026-02-09

### Added
- **`pwsh` Script Type**: Added `pwsh` as an alias for `powershell` in script commands
  - `var x = run pwsh "./script.ps1"` now works alongside `run powershell`
- **Bare Variable Support in Property Assignments**: Variables can be assigned without `{{}}` syntax
  - `payload.userId = dynamicUserId` now works (previously required `{{dynamicUserId}}`)
- **Request Body in Verbose Output**: CLI `-v` flag now shows the actual request body and headers sent
  - Helps debug payload issues by showing exactly what was transmitted

### Fixed
- **Script Output Capture**: Fixed variable shadowing bug that could affect JSON parsing of script output

## [1.3.8] - 2026-02-09

### Fixed
- **Named Requests with Endpoint Syntax**: Fixed `run RequestName` failing when the named request uses `.nornapi` endpoint syntax
  - `[PostFormWithEndpoint]` with `POST HttpBinPost Form` now works correctly when invoked via `run PostFormWithEndpoint`
  - Endpoint is resolved and headers/body are properly applied

## [1.3.7] - 2026-02-09

### Fixed
- **Named Requests with Header Groups**: Fixed `run RequestName` failing when the named request uses header groups
  - `run GetWithJsonHeader` now correctly applies the `Json` header group instead of appending it to the URL
  - Regression from 1.3.4 header groups fix

## [1.3.6] - 2026-02-09

### Added
- **Empty Array and Object Assertions**: Support for asserting against empty literals
  - `assert $1.body.items == []` now works for empty array comparison
  - `assert $1.body.data == {}` now works for empty object comparison

## [1.3.5] - 2026-02-09

### Fixed
- **Endpoint Syntax Body Extraction**: Fixed form body not being sent with named requests using endpoint syntax
  - `[PostFormWithEndpoint]` followed by `POST HttpBinPost Form` and body lines now works correctly
  - Applies to standalone named requests (outside sequences) using `.nornapi` endpoints
- **Header Group Syntax Highlighting**: Fixed header group not showing green when on same line as URL
  - `POST {{url}}/post Form` now correctly colors `Form` as header group

## [1.3.4] - 2026-02-09

### Fixed
- **Header Groups with Raw URLs**: Header groups now work with regular URL requests, not just endpoint syntax
  - `GET https://example.com/api Json` now correctly applies the Json header group
  - Header groups on separate lines after URL also work
  - Both extension and CLI support this fix
  - Named requests (`[RequestName]`) also support header groups with raw URLs
- **CLI Named Requests with Endpoints**: Fixed body not being sent when using endpoint syntax
  - `POST HttpBinPost Form` with body lines now correctly sends the form data
- **Syntax Highlighting for Form Parameters**: Added proper coloring for URL-encoded form body parameters
  - `firstname=Alice` now shows key as parameter (purple), `=` as operator, value as string

## [1.3.3] - 2026-02-08

### Fixed
- **Contract View Panel**: Fixed webview rendering issue that showed raw JavaScript code
  - Removed embedded script tags that broke HTML parsing
  - "View Contract Details" button now works correctly
- **Contract View Styling**: Unified appearance with Contract Report
  - Response JSON now has proper syntax highlighting (colored keys, strings, numbers)
  - Schema JSON has consistent styling without background highlight artifacts
- **Gutter Decorations**: Removed contract gutter icons and line highlights for cleaner editor appearance

## [1.3.2] - 2026-02-08

### Improved
- **Contract Report View**: Enhanced property highlighting in the annotated JSON view
  - Color-coded property highlights (green=valid, yellow=warning, red=error)
  - Highlights wrap only the property content, not the entire line
  - Selection-style highlighting similar to assert hover
  - Improved indentation and spacing

### Fixed
- **Syntax Highlighting**: Fixed JSON body coloring after nested objects
  - Properties following `{ }` objects now correctly colored
- **matchesSchema Keyword**: Fixed partial coloring issue
  - Entire keyword now highlights as operator (was matching "matches" first)

## [1.3.1] - 2026-02-08

- **Clickable JSON Properties**: Click any JSON value in the response panel to generate an assertion
  - Hover over any value (string, number, boolean, null) to highlight it
  - Click to automatically insert `assert $var.body.path == value` at the end of the sequence
  - Works with nested objects and arrays (e.g., `body.user.address.city`, `body.items[0].name`)
  - String values are properly escaped with quotes
  - Toast notification confirms assertion added

- **Response Comparison**: Compare any two API responses with VS Code's built-in diff view
  - New "⇄ Compare" button next to "📋 Copy" on response bodies
  - Click on first response, then click another to open side-by-side diff
  - Responses are pretty-printed JSON for easy comparison
  - Toast notification guides user: "Select another response to compare"
  - Works in both sequence results and single request views
  - State resets automatically after diff opens

## [1.3.0] - 2026-02-07

### Added- **Retry and Backoff**: Automatically retry failed HTTP requests with configurable backoff
  - Syntax: `GET url retry 3 backoff 200 ms` (retry up to 3 times with 200ms linear backoff)
  - Works with direct URLs, named endpoints, and named requests
  - Supports time units: `ms`, `s`, `seconds`, `milliseconds`
  - Response panel shows retry indicator: 🔄 `retried 2x`
  - CLI shows retry attempts in real-time
  - Retries on 5xx errors, 429 rate limiting, and network failures

### Improved
- **Syntax highlighting**: Variable references `{{var}}` now highlighted inside print strings
- **Better pattern recognition**: `test sequence` correctly terminates request blocks in all contexts

## [1.2.5] - 2026-02-07

### Improved
- **Rich HTML Reports**: Completely redesigned HTML report output for QA professionals
  - **Pass rate badge**: Large visual indicator showing pass percentage (green/yellow/red)
  - **Filter bar**: Search tests by name, filter by All/Passed/Failed
  - **Clickable stat cards**: Click total/passed/failed to filter results
  - **Expand/Collapse All**: Buttons to quickly expand or collapse all test details
  - **Failures first**: Failed tests automatically sorted to top and expanded
  - **Friendly assertion names**: Shows `user.body.status` instead of `$1.body.status`
  - **JSON path context**: Failed assertions show the path that failed
  - **Variable labels on requests**: Shows `user = GET /api/users` instead of `$1`
  - **Environment display**: Shows which environment was used in report header

## [1.2.4] - 2026-02-07

### Improved
- **Enhanced failure experience**: Failed assertions now display much richer context
  - **Friendly variable names**: Shows `user.body.status` instead of `$1.body.status` when response was assigned to a variable
  - **Auto-expand failures**: Failed assertions automatically expand to show details
  - **Inline response preview**: Failed assertions include a collapsible preview of the related response body
  - **JSON path highlighting**: The failing field is highlighted in the response preview
  - **Request labels**: Request steps in sequences show variable names (e.g., `user`) instead of `$1`
- Same improvements apply to CLI output and Test Explorer

## [1.2.3] - 2026-02-07

### Added
- **Duplicate import detection**: Errors shown when importing files with duplicate definitions
  - Header groups and endpoints from `.nornapi` files
  - Named requests and sequences from `.norn` files
  - Blocks execution in CLI, VS Code, and Test Explorer
  - Red squiggly on import line with descriptive error message

### Fixed
- **.nornenv validation**: `secret var = value` now shows error (use `secret name = value` instead)
  - Syntax highlighting marks invalid pattern in red
  - Diagnostic message explains correct usage
- **IntelliSense context**: Script types (`bash`, `powershell`, `js`, `readJson`) only appear after `run` keyword
- **var keyword highlighting**: `var` keyword stays colored while typing variable name

## [1.2.2] - 2026-02-05

### Added
- **Coverage for sub-sequences**: Coverage now follows `run SequenceName` calls to track API calls in nested sequences
- **Coverage for named request blocks**: Named request blocks (`[RequestName]`) with hardcoded URLs are now matched to swagger endpoints by URL path
- **Auto-refresh coverage on save**: Coverage panel updates automatically when `.norn` or `.nornapi` files are saved

### Improved
- **IntelliSense for .nornapi files**: Content-Type header completions now work in `.nornapi` files (previously only worked in `.norn`)

## [1.2.1] - 2026-02-03

### Added
- **Inline headers for API endpoints**: Stack custom headers below endpoint calls from `.nornapi` files
  - Example: `GET Login` followed by `x-api-key: "my-key"` on the next line
  - Mix inline headers with header groups (e.g., `Common`)
  - Inline headers take precedence over header group values
  - Syntax highlighting for inline headers after API endpoint calls

### Improved
- **IntelliSense for header values**: After selecting `Content-Type`, IntelliSense automatically triggers to show content type options (`application/json`, etc.)
- **Removed snippet tab stops**: Header completions no longer leave you in snippet mode requiring Tab to exit
- **Better trigger characters**: Added `:` as trigger character for immediate header value suggestions

## [1.2.0] - 2026-02-02

### Added
- **Swagger API Coverage**: See percentage coverage of your OpenAPI/Swagger endpoints
  - Status bar indicator shows coverage percentage when swagger specs are detected
  - Click to open detailed coverage panel with per-endpoint breakdown
  - Coverage tracks asserted status codes (200, 400, 404, etc.) per endpoint
  - Supports wildcard matching (2xx, 4xx, 5xx)
  - Only counts `test sequence` blocks toward coverage
  - CodeLens on swagger lines shows coverage at a glance
  - Automatic recalculation after test execution
  - Caches swagger specs for performance

## [1.1.4] - 2026-02-02

### Fixed
- **Inline comments**: Fixed syntax highlighting and execution for inline comments
- **URL highlighting**: URLs now colored as strings with variable interpolation support
- **Duplicate detection**: Diagnostics for duplicate variables, named requests, and sequences

## [1.1.3] - 2026-02-01

### Fixed
- **@data shorthand for single parameter**: `@data(1, 2, 3)` with a single parameter now correctly creates 3 test cases instead of 1 case with 3 values
  - Example: `@data(1, 2, 3) test sequence Foo(id)` now runs 3 times with `id=1`, `id=2`, `id=3`
  - Multi-parameter syntax unchanged: `@data(1, "a")` per line for each test case

## [1.1.2] - 2026-02-01

### Added
- **VS Code Test Explorer Integration**: Run test sequences from the Testing sidebar
  - Automatic test discovery for all `.norn` files
  - Tests grouped by tag (`@smoke`, `@regression`, etc.)
  - Colorful streaming output with ANSI colors
  - Persistent output when selecting tests
  - Detailed failure info with expected vs actual diffs
  - Request/response details for failed HTTP calls

- **Parameterized Tests**: Data-driven testing with `@data` and `@theory` annotations
  - `@data(1, "Widget")` syntax for inline test data
  - `@theory("./testdata.json")` for external data files
  - Typed value parsing (numbers, booleans, strings)
  - Each data row creates a separate test case in Test Explorer
  - Example: `@data(1, 200)` with `test sequence ValidateStatus(id, expectedStatus)`

- **Test Sequence Validation**: Diagnostics for test annotations
  - Error if `@data`/`@theory` used on regular sequences (must use `test sequence`)
  - Error if tags like `@smoke` used on regular sequences
  - Error if test sequence has required params but no `@data`/`@theory`

### Improved
- **Test Explorer Output**: Rich colorized output with icons
  - HTTP methods in cyan, status codes color-coded (green/red/yellow)
  - Checkmarks for passed assertions, X for failures
  - Clear test headers when running multiple tests
  - Duration shown for each test

## [1.1.0] - 2026-02-01

### Added
- **Test Sequences**: Mark sequences as tests with `test sequence Name` syntax
  - Only `test sequence` blocks run from CLI; plain `sequence` blocks are helpers
  - Use helpers for shared setup/utility sequences called by tests
  - Example: `test sequence AuthFlow` runs from CLI, `sequence SetupUser` is a helper

- **Directory Discovery**: Run all test sequences in a directory tree
  - `npx norn tests/` recursively finds and runs all `.norn` files
  - Aggregates results across all files with combined summary
  - Only `test sequence` blocks are executed

- **Output Directory**: Save reports to a custom location with timestamped filenames
  - `--output-dir ./reports` saves results to specified directory
  - Auto-generates timestamped filenames: `tests-2026-02-01-120000-results.xml`
  - Works with `--junit` and `--html` reporters

- **Secret Variables**: Mark sensitive environment variables with `secret` keyword
  - Syntax: `secret apiKey = my-secret-key` in `.nornenv` files
  - Values automatically redacted as `***` in all CLI output
  - Prevents accidental exposure of tokens, passwords, API keys

- **Human-Readable CLI Output**: Colorized, formatted output for terminal
  - Pass/fail indicators with colors and Unicode symbols
  - Assertion results with expected vs actual values
  - Request/response details in verbose mode

- **JUnit Reporter**: Generate XML reports for CI/CD pipelines
  - `--junit` flag outputs JUnit-compatible XML
  - Compatible with GitHub Actions, Jenkins, Azure DevOps
  - Includes test names, durations, failure messages

- **HTML Reporter**: Generate visual HTML reports
  - `--html` flag outputs styled HTML report
  - Expandable sections for requests, responses, assertions
  - Easy sharing and archiving of test results

### Fixed
- **Print Statement Variable Resolution**: `{{$1.status}}` now resolves correctly in print statements
  - Response references (`$1`, `$2`, etc.) are now stored in runtime variables
  - Works in both print statements and variable assignments

## [1.0.26] - 2026-01-31

### Added
- **Sequence Tags**: Tag sequences with `@smoke`, `@team(CustomerExp)` for filtering in CI/CD
  - Simple tags: `@smoke @regression` before `sequence` declaration
  - Key-value tags: `@team(CustomerExp)`, `@priority(high)`, `@jira(NORN-123)`
  - Multiple tags on same line or separate lines
  - Case-insensitive tag matching

- **CLI Tag Filtering**: Filter sequences by tags when running from command line
  - `--tag smoke` - AND logic (can repeat: `--tag smoke --tag auth`)
  - `--tags smoke,regression` - OR logic (comma-separated)
  - Key-value matching: `--tag team(CustomerExp)`
  - Nested sequences silently skipped when tag filter is active and they don't match

- **Tag IntelliSense**: Type `@` to see existing tags from workspace
  - Auto-completes simple tags and key-value tags
  - Suggests common tags: `smoke`, `regression`, `wip`, `skip`, `team`, `priority`

- **Tag Diagnostics**: Warning when tags are placed incorrectly (not before `sequence`)

### Changed
- **Regression Test Filtering**: Regression CLI runs support `--tag` and `--tags` options
  - Example: `node ./dist/cli.js tests/Regression/ --env prelive --tag smoke` runs only smoke-tagged sequences

## [1.0.25] - 2026-01-28

### Added
- **Capture Named Request Response**: `var response = run NamedRequest` now works
  - Previously only `run NamedRequest` (without capture) worked
  - Now you can capture the full HTTP response including `status`, `body`, and `headers`
  - Example: `var resp = run GetSingleTodo` then `assert resp.status == 200`

## [1.0.24] - 2026-01-27

### Changed
- **Single Return Values**: Single returns now pass the raw value, not a wrapped object
  - `return myValue` → caller receives the value directly (e.g., `"level-3-data"`)
  - `return a, b` → caller receives `{a: valueA, b: valueB}` object
  - This matches intuitive behavior: "return the value" means pass the value itself
  - Example: `var result = run GetEmail` where `GetEmail` does `return email` → `result` is the email string

### Fixed
- **Regression Tests**: Updated test expectations to match correct single-return behavior
  - Tests now correctly assert raw values instead of accessing `.property` on single returns

## [1.0.23] - 2026-01-26

### Fixed
- **Sequence Return Value Consistency**: Single and multiple return statements now behave identically
  - Fixed `assert result.value == "data"` failing with "Variable not defined" for single returns
  - All return values are now wrapped in a JSON object, so `result.myValue` works consistently

- **API Endpoint Request Bodies**: POST/PUT/PATCH with endpoint syntax now includes the body
  - Fixed `POST HttpBinPost Json` followed by `{"test": "data"}` sending empty body
  - Body lines after endpoint requests are now correctly extracted and sent

- **Variable Quote Stripping**: Quoted string values are now stored without quotes
  - Fixed `var url = "https://example.com"` being used as `"https://example.com"/path`
  - Quotes are stripped during variable extraction for cleaner substitution

## [1.0.22] - 2026-01-26

### Fixed
- **Standalone API Requests**: `GET GetPetById(1)` now works outside of sequences
  - Fixed "Invalid URL" error when clicking CodeLens on API endpoint requests
  - API detection now correctly skips blank lines, comments, and import lines

## [1.0.21] - 2026-01-25

### Fixed
- **Script Variable Capture**: `var id = run powershell "script.ps1"` now correctly captures and parses JSON output
  - Script output is automatically parsed as JSON when valid, enabling `id[0].property` access
  - Fixed detection to not confuse `run powershell` with `run SequenceName`

- **Sequence Return Values**: `return id[0].id` now correctly returns nested values
  - Fixed path parsing for array and property access in return statements
  - Return values preserve their type (number, object, etc.) instead of being stringified

- **Sub-sequence API Endpoints**: API endpoints now work correctly in sub-sequences
  - Fixed `GET GetUser(id)` not resolving when called from `run Get_200(id)`
  - API definitions are now properly passed to nested sequence calls

## [1.0.20] - 2026-01-25

### Added
- **Swagger/OpenAPI Import**: Import endpoints from OpenAPI specifications in `.nornapi` files
  - Add `swagger https://api.example.com/swagger.json` to your `.nornapi` file
  - Click "Import Endpoints" CodeLens button to fetch and parse the spec
  - Select which sections to import (All, or specific tags like pet/store/user)
  - Customize the base URL for generated endpoints
  - Supports OpenAPI 2.0 (Swagger) and OpenAPI 3.x specifications
  - Generates clean endpoint definitions: `EndpointName: METHOD /path`

## [1.0.19] - 2026-01-25

### Improved
- **Simplified IntelliSense**: Completions now insert just the keyword without extra placeholders
  - HTTP methods insert `GET ` instead of `GET https://` with snippet
  - `var`, `run`, `assert` insert just the keyword for natural typing
  - Endpoint completions insert just the name, letting you add `()` manually

- **Better Syntax Highlighting for JSON Bodies**: Full JSON coloring in request bodies
  - Property keys highlighted as property names
  - String values highlighted as strings
  - Numbers highlighted as numbers
  - Variable references `{{var}}` highlighted inside strings
  - Works with or without blank line between headers and body

- **Print Statement Syntax Highlighting**: Distinct colors for different elements
  - Quoted strings show string color
  - Variables show variable color
  - `+` operator highlighted

- **Variable Assignment Highlighting**: Better coloring for `var x = value`
  - Variable paths like `result[0].id` highlighted as variables (not strings)

### Added
- **Missing Concatenation Diagnostics**: Red squiggly when `+` is missing between values in print
  - `print "Result: " result` shows error between string and variable
  - Suggests adding `+` operator

- **Missing Parameter Diagnostics**: Red squiggly when calling sequence without required parameters
  - `run Teardown` shows error if `Teardown(sessionId)` requires a parameter
  - Shows required parameter names in error message

### Fixed
- Auto-closing parentheses now works - typing `(` inserts `)`
- IntelliSense triggers when typing inside parentheses

## [1.0.18] - 2026-01-24

### Added
- **Variable Request Capture**: Capture HTTP responses into variables for stable assertions
  - Syntax: `var user = GET {{baseUrl}}/users/1` or `var user = GET GetUser(1) Json`
  - Access response properties: `user.body.username`, `user.status`, `user.headers`
  - Eliminates need for fragile `$1`, `$2` references that break when requests change
  - Full support for named endpoints with header groups

- **IntelliSense for Variable Request Capture**
  - HTTP methods (GET, POST, etc.) shown after `var x = `
  - Endpoint suggestions from `.nornapi` files after method
  - Header group suggestions after endpoint (Auth, Json, etc.)
  - Response property completions for captured variables (`user.body.`, `user.headers.`)

- **Diagnostics for Variable Request Capture**
  - Red squiggly for undefined endpoints in `var x = GET UnknownEndpoint`
  - Red squiggly for undefined header groups in `var x = GET GetUser(1) InvalidGroup`

- **Syntax Highlighting for Variable Request Capture**
  - Endpoint name styled as function
  - Parameters styled appropriately
  - Header groups styled in green (matching other header group references)

## [1.0.17] - 2026-01-24

### Added
- **API Definition Files (.nornapi)**: New file format for defining reusable API configurations
  - Define header groups with `headers GroupName` / `end headers`
  - Define endpoint templates with `endpoints /path` / `end endpoints`
  - Import into .norn files with `import "./api.nornapi"`
  - IntelliSense support for .nornapi keywords and common headers
  - Custom file icon for .nornapi files

- **Enhanced Sequence Request Display**: Request steps in sequences now show full details
  - URL display with method badge (color-coded by HTTP method)
  - Tabs for Body, Headers, and Cookies (same as single request view)
  - Copy button for response body
  - JSON syntax highlighting in response body

- **File Icons**: Custom icons for Norn file types
  - `.nornapi` files show network connection icon
  - `.nornenv` files show globe icon

### Fixed
- Comments no longer show diagnostic errors for undefined variables
- Lines starting with `#` or `//` are properly skipped during variable validation

## [1.0.16] - 2026-01-24

### Added
- **Sequence Parameters**: Sequences can now accept parameters with optional default values
  - Declare parameters: `sequence Login(username, password = "secret123")`
  - Call with positional args: `run Login("admin", "mypass")`
  - Call with named args: `run Login(password: "pass", username: "user")`
  - Parameters with defaults are optional
  - Required parameters must come before optional ones

- **Sequence Return Values**: Sequences can return multiple values
  - Return statement: `return token, userId`
  - Capture in caller: `var result = run Login("admin")`
  - Access fields: `{{result.token}}`, `{{result.userId}}`

- **IntelliSense for Return Fields**: Property completions for sequence return values
  - Type `{{result.` to see available fields from the sequence's return statement
  - Works for sequences in the same file and imported files

- **CLI Print Support**: Print statements now display in CLI output with `[print]` prefix

### Fixed
- Sequence parameters no longer show as undefined variables in diagnostics
- CodeLens "Run Sequence" now shows for sequences where all parameters have defaults

### Examples

```norn
sequence CreateUser(name, role = "user", active = "true")
    print Creating {{name}} with role {{role}}
    POST {{baseUrl}}/users
    Content-Type: application/json
    {"name": "{{name}}", "role": "{{role}}", "active": {{active}}}
    
    var id = $1.body.id
    return id, name, role
end sequence

sequence TestUsers
    # Positional args
    var admin = run CreateUser("Admin", "admin", "true")
    print Admin ID: {{admin.id}}
    
    # Named args (any order)
    var guest = run CreateUser(role: "guest", name: "Guest")
    print Guest ID: {{guest.id}}
    
    # Use defaults
    run CreateUser("DefaultUser")
end sequence
```

## [1.0.15] - 2026-01-24

### Added
- **Sequence Composition**: Sequences can now call other sequences with `run SequenceName`
  - Enables modular test design with reusable setup/teardown patterns
  - Variables set in called sequences are available to the caller
  - Sequences can be nested to any depth
  - Circular references are detected and reported as errors
  - Sub-sequences shown in collapsible groups in the response panel

- **File Imports**: Import named requests and sequences from other files
  - `import "./common.norn"` - import from relative path
  - Nested imports supported (imported files can import other files)
  - Circular imports detected and reported
  - Variables resolved at import time (baked in), not exported
  - `.nornenv` environment variables shared across all files

- **Response Panel Improvements**:
  - Steps start collapsed by default for cleaner view
  - "Expand All" / "Collapse All" button in sequence header
  - Sub-sequence calls shown in collapsible groups with 📦 icon
  - Failed sub-sequences show error styling

### Examples

```norn
# common.norn - shared utilities
var baseUrl = https://api.example.com

[AuthRequest]
POST {{baseUrl}}/auth/login
Content-Type: application/json
{"username": "admin", "password": "secret"}

sequence SharedSetup
    run AuthRequest
    var token = $1.body.accessToken
end sequence
```

```norn
# main-test.norn
import "./common.norn"

sequence MyTests
    run SharedSetup
    
    GET {{baseUrl}}/users/me
    Authorization: Bearer {{token}}
    assert $1.status == 200
end sequence
```

## [1.0.14] - 2026-01-23

### Added
- **Variable expression assignment**: Assign variables from expressions without `{{}}`
  - `var id = data.users[0].id` - extract from JSON variable
  - `var name = "John"` - quoted string literals
  - `var count = 123` - numeric literals
  - `var active = true` - boolean literals
- **PowerShell output parsing**: Automatic parsing of PowerShell table/list output to JSON
  - Table format with headers and `---` separators
  - List format with `Key : Value` pairs
  - ANSI escape code stripping for clean output
- **Improved syntax highlighting**: Different colors for value types in variable assignments
  - Quoted strings, numbers, booleans, variable references, URLs
- **IntelliSense for variable assignments**: After `var x = `, shows:
  - Defined variables with their values
  - Keywords: `true`, `false`, `null`
  - Run commands
- **Diagnostic for invalid assignments**: Red squiggly for:
  - Unquoted strings with spaces: `var x = hello world`
  - Undefined variable references: `var x = unknownVar`

### Examples

```norn
sequence DataExtraction
    # Load JSON data
    var config = run readJson ./config.json
    
    # Extract values directly (no {{}} needed)
    var userId = config.users[0].id
    var userName = config.users[0].name
    
    # Use string literals with interpolation
    var greeting = "Hello {{userName}}"
    
    # PowerShell scripts now auto-parse to JSON
    var dbResult = run powershell ./query.ps1
    var recordId = dbResult.Id
    
    print Result | User {{userId}}: {{userName}}
end sequence
```

## [1.0.13] - 2026-01-22

### Added
- **`wait` command**: Pause execution for a specified duration
  - Formats: `wait 2s`, `wait 500ms`, `wait 1.5 seconds`
  - Useful for testing async operations or rate-limited APIs
- **`if` statements**: Conditional execution of steps based on response data
  - Use any assertion operator: `if $1.status == 200 ... end if`
  - Supports nesting: multiple if blocks can be nested
  - Skipped steps are not executed when condition is false
- **`isType` assertion**: Type checking for response values
  - Supported types: `number`, `string`, `boolean`, `array`, `object`, `null`
  - Example: `assert $1.body.id isType number`
  - Example: `assert $1.body.tags isType array`
- **CLI improvements**:
  - `--env` / `-e`: Select environment from `.nornenv`
  - `--request` / `-r`: Run a specific named request
  - `--timeout` / `-t`: Request timeout in seconds
  - `--verbose` now shows response headers

### Examples

```norn
sequence ConditionalExample
    GET {{baseUrl}}/users/1
    
    # Type assertions
    assert $1.body.id isType number
    assert $1.body.name isType string
    assert $1.body.roles isType array
    
    # Conditional execution
    if $1.status == 200
        print Success | User found
        
        # Wait before next request (rate limiting)
        wait 1s
        
        GET {{baseUrl}}/users/1/profile
        assert $2.status == 200
    end if
    
    if $1.status == 404
        print Not Found | User does not exist
    end if
end sequence
```

## [1.0.12] - 2026-01-22

### Added
- **JSON file reading**: Load JSON files into variables with `var config = run readJson ./path/to/file.json`
  - Access nested properties: `{{config.database.host}}`, `{{config.users[0].name}}`
  - Modify properties inline: `config.apiKey = {{newKey}}`
- **IntelliSense for `run` commands**: Typing `run` and selecting it automatically triggers IntelliSense showing available options:
  - Script types: `bash`, `powershell`, `js`, `readJson`
  - Named requests defined in the file
- **Method icons**: Script type completions now show method icons for better visual distinction
- **Smart IntelliSense triggers**: Space after `run` automatically shows available options

### Changed
- **Simplified completions**: Removed snippet placeholders from `run` command completions - now inserts plain text for cleaner experience
- **Refactored completion logic**: `run` command completions now share logic between standalone `run` and `var x = run` contexts

## [1.0.11] - 2026-01-21

### Added
- **Assertions**: New `assert` command for validating HTTP responses in sequences
  - Operators: `==`, `!=`, `>`, `>=`, `<`, `<=`, `contains`, `startsWith`, `endsWith`, `matches`, `exists`, `!exists`
  - Assert on status: `assert $1.status == 200`
  - Assert on body: `assert $1.body.userId == 1`
  - Assert on headers: `assert $1.headers.Content-Type contains "application/json"`
  - Assert duration: `assert $1.duration < 5000`
  - Custom failure messages: `assert $1.body.id == 999 | "Expected different ID"`
- **IntelliSense for response properties**: After typing `$1.`, shows completions for `status`, `statusText`, `headers`, `body`, `duration`
- **Assertion syntax highlighting**: `assert` commands now have proper syntax coloring

### Changed
- **BREAKING**: Response body access now requires explicit `body.` prefix
  - Before: `$1.userId` or `$1[0].title`
  - After: `$1.body.userId` or `$1.body[0].title`
  - This makes it clearer what you're accessing (status vs headers vs body)

## [1.0.10] - 2026-01-20

### Fixed
- **PowerShell 7 support**: Now prefers `pwsh` (PowerShell 7+) over `powershell` (Windows PowerShell 5.1) for script execution. PowerShell 7 has newer SqlClient drivers that support additional connection string options like `HostNameInCertificate`. Falls back to Windows PowerShell if pwsh is not installed.

## [1.0.9] - 2026-01-20

### Added
- **Streaming sequence results**: Sequence steps now appear in the response panel as they complete, providing real-time feedback during long-running sequences
- **Variable assignment IntelliSense**: After typing `var x = run `, IntelliSense now shows available script types (bash, powershell, js) AND named requests to run
- **Named request capture syntax**: Support for `var result = run MyRequest` to capture a named request's response into a variable

### Fixed
- **`run` keyword highlighting**: The `run` keyword is now properly highlighted while typing, before completing the full command
- **Partial command highlighting**: `var x = run` and `var x = run bash` now highlight correctly while still typing
- **IntelliSense after `run `**: Typing `run ` (with trailing space) now properly triggers IntelliSense suggestions
- **Sequence re-run cleanup**: Running a sequence again now properly clears previous results instead of appending to them

## [1.0.8] - 2026-01-19

### Added
- **Add env file**: When no `.nornenv` file exists, CodeLens shows "**+ Add env file**" - clicking it creates a template file with common variables and dev/prod environments ready to customize

### Fixed
- **Parser fix**: Body extraction now stops at request boundaries (`[SomeName]`, `sequence`, HTTP methods). Previously `[SomeName]` after URL-encoded params was incorrectly included in the body.

## [1.0.7] - 2026-01-19

### Fixed
- **Syntax highlighting**: Proper stateful parsing - headers before blank line get header color, body params after blank line get parameter color (like the parser does)

## [1.0.6] - 2026-01-19

### Fixed
- **URL-encoded body support**: Now supports `key: value` format (colon) in addition to `key=value` for form data
- **Syntax highlighting**: Body parameters now have distinct highlighting from headers (different color for `username:` vs `Content-Type:`)

## [1.0.5] - 2026-01-19

### Fixed
- **Fixed**: File icon resolution 
- **Fixed header/body parsing**: Parser now uses blank line to separate headers from body (standard HTTP convention). This fixes 400 errors when URL-encoded form data params like `username: value` were incorrectly parsed as headers.

## [1.0.4] - 2026-01-19

### Added
- **Named Requests**: Define reusable requests with `[RequestName]` and call them with `run RequestName` in sequences
- **Environment Support**: Create `.nornenv` file with environment-specific variables
  - Common variables available in all environments
  - Switch environments via status bar or CodeLens
  - Environment variables shown in IntelliSense with source indicator
- **URL-encoded Form Data**: Support for `application/x-www-form-urlencoded` with multi-line format
- **Environment Selector in CodeLens**: Click `env: dev` next to Send Request to switch environments

### Changed
- Changed language ID from `http` to `norn` to avoid conflicts with other extensions
- Improved syntax highlighting for `[RequestName]` declarations and `run` commands

### Fixed
- Diagnostics now respect environment variables (no false "undefined variable" errors)
- Diagnostics refresh when switching environments
- Named request names now enforce no-spaces rule with error highlighting

## [1.0.3] - 2026-01-18

- Fix 'sequence' not being recognized as a keyword
- Fixed an issue where if the name was of the sequence had a '-' it will be highlighted incorrectly 

## [1.0.2] - 2026-01-18

### Added
- Capture entire response body with `var data = $1`
- Capture array elements with `var item = $1[0]`
- Extended evaluation period to 30 days

### Fixed
- Array index capture syntax now works correctly (`$1[0].field`)

## [1.0.1] - 2026-01-18

### Fixed
- Improved file icon resolution (128x128)
- Updated license badge in README

## [1.0.0] - 2025-01-15

### Added
- **HTTP Requests**: Send GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS requests
- **Variables**: Define with `var name = value`, reference with `{{name}}`
- **Sequences**: Chain multiple requests with `sequence Name` / `end sequence`
- **Response Capture**: Capture values from responses with `$N.path` syntax
- **Script Execution**: Run bash, PowerShell, or JavaScript scripts with `run` command
- **Print Statements**: Debug output with `print Message` or `print Title | Body`
- **Cookie Support**: Automatic cookie jar with persistence across requests
- **Syntax Highlighting**: Full highlighting for HTTP methods, headers, JSON bodies
- **IntelliSense**: Autocomplete for methods, headers, variables, and keywords
- **Diagnostics**: Error highlighting for undefined variables
- **CLI Tool**: Run requests from terminal with JSON output for CI/CD pipelines
- **Response Panel**: Webview with formatted JSON and execution results
