onec-interactive-runtime-core 0.1.20__tar.gz → 0.1.21__tar.gz

{onec_interactive_runtime_core-0.1.20 → onec_interactive_runtime_core-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: onec-interactive-runtime-core
-Version: 0.1.20
+Version: 0.1.21
 License-Expression: GPL-3.0-only AND MIT
 License-File: COPYRIGHT
 License-File: LICENSE

{onec_interactive_runtime_core-0.1.20 → onec_interactive_runtime_core-0.1.21}/README.md

@@ -8,14 +8,14 @@
 
 Нужны Windows, Python 3.12+, VS Code 1.136+, установленная платформа 1С, **отдельная копия ИБ** и локальная копия выгрузки исходников той же конфигурации. По умолчанию runtime устанавливает в ИБ служебное расширение. Демо проверены на платформе **8.5.1.1529**: ЗУП — с **ЗУП КОРП 3.1.38.92** и снимком данных от **01.08.2021**, УТ — с **УТ 11.6.1.61** (дата данных определяется из ИБ). Платформа, демобазы и выгрузки в пакет не входят.
 
-Скачайте **Source code (zip)** из [релиза v0.1.20](https://github.com/pulh1/bsl-jupyter-runtime/releases/tag/v0.1.20) и распакуйте архив: в нём находятся `notebooks/demo`. Из [релиза v0.1.18](https://github.com/pulh1/bsl-jupyter-runtime/releases/tag/v0.1.18) скачайте `bsl-notebook-0.1.4.vsix`. VSIX отвечает за подсказки BSL в редакторе; Python-пакеты версии 0.1.20 устанавливаются из PyPI.
+Скачайте **Source code (zip)** из [релиза v0.1.21](https://github.com/pulh1/bsl-jupyter-runtime/releases/tag/v0.1.21) и распакуйте архив: в нём находятся `notebooks/demo`. Из [релиза v0.1.18](https://github.com/pulh1/bsl-jupyter-runtime/releases/tag/v0.1.18) скачайте `bsl-notebook-0.1.4.vsix`. VSIX отвечает за подсказки BSL в редакторе; Python-пакеты версии 0.1.21 устанавливаются из PyPI.
 
 В PowerShell из папки распакованного проекта создайте окружение, установите пакет и зарегистрируйте kernel:
 
 ```powershell
 py -3.12 -m venv .venv
 $python = ".\.venv\Scripts\python.exe"
-& $python -m pip install "onec-interactive-jupyter==0.1.20" "ipykernel>=6.29,<7" "matplotlib>=3.11,<4"
+& $python -m pip install "onec-interactive-jupyter==0.1.21" "ipykernel>=6.29,<7" "matplotlib>=3.11,<4"
 & $python -m ipykernel install --user --name onec-bsl --display-name "1C BSL"
 ```
 

onec_interactive_runtime_core-0.1.21/docs/superpowers/plans/2026-09-18-bsl-error-diagnostics-main.md

@@ -0,0 +1,362 @@
+# BSL Error Diagnostics on MAIN/CAPTURE Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Show the full bounded 1C cause chain and stack for failed BSL cells, remapped through exact notebook/Worker source maps, in the redesigned runtime and Jupyter adapter.
+
+**Architecture:** Port the pure parser and trace model from `feature/bsl-error-diagnostics-core`; do not port its former `runtime_api` execution logic. Enrich only confirmed failures in `src/onec_runtime/execution`, using the operation's already-held Worker pin, and render the resulting private trace in `packages/jupyter`.
+
+**Tech Stack:** Python 3.13, pytest, uv, 1C RDBG and BSL, Jupyter/IPython.
+
+**Spec:** `docs/superpowers/specs/2026-09-18-bsl-error-diagnostics-main-design.md`
+
+## Global Constraints
+
+- Work on `feature/bsl-error-diagnostics-main` from master; do not merge master or the old feature branch wholesale.
+- Read root and nested `AGENTS.md` before each component edit: `src/onec_runtime`, `src/onec_runtime/execution` and its `controller`, `main`, `capture` directories, `packages/jupyter`, `packages/mcp` if touched, and `tests`.
+- Preserve MAIN/CAPTURE's single RDBG arbiter, operation fences, existing Worker pins, and successful-cell behavior. No diagnostic-specific RDBG request, pin, cache, parse, filesystem read, or other success-path work.
+- Keep verbatim private 1C evidence at most 64 KiB UTF-8, at most 32 causes and 128 frames, with independent truncation flags. Do not invent missing 1C frames.
+- Native 1C module coordinates need no source map. `source_root` only adds a local file hint or verified excerpt; its absence or failure cannot hide the platform text.
+- Keep compact/public diagnostic payloads bounded and without source strings or raw 1C text. Do not add the deferred MCP expert schema.
+- Run focused static tests before wider static tests. Live 1C qualification is opt-in, uses a disposable infobase, and must not commit its evidence.
+
+## File ownership map
+
+| File | Responsibility |
+|---|---|
+| `src/onec_runtime/bsl/diagnostics.py` | Pure bounded parser, ordered cause/frame model and source-map enrichment. |
+| `src/onec_runtime/runtime_contracts.py`, `src/onec_runtime/privacy.py` | Trace validation and private/public serialization bounds. |
+| `packages/mcp/src/onec_runtime_mcp/agent/operations.py`, `packages/mcp/src/onec_runtime_mcp/server.py` | Keep existing private/expert validation at the same byte bound without adding a tool or wire keys. |
+| `src/onec_runtime/worker_universe.py` | Read exact diagnostic artifacts through an existing `OperationGenerationPin`. |
+| `src/onec_runtime/execution/worker_activation.py` | Narrow read-only evidence adapter for an already-held lease. |
+| `src/onec_runtime/execution/controller/controller.py` | Attach error-only evidence to confirmed MAIN/CAPTURE outcomes before pin release. |
+| `src/onec_runtime/execution/reply_publication.py` | Normalize confirmed error text into `RuntimeReply.diagnostic`; never own RDBG. |
+| `packages/jupyter/src/onec_runtime_jupyter/diagnostic_trace.py` | Human-only reason, stack and raw-detail formatting. |
+| `packages/jupyter/src/onec_runtime_jupyter/diagnostic_sources.py` | Optional safe local source-file hints under configured `source_root`. |
+| `packages/jupyter/src/onec_runtime_jupyter/extension.py` | Display integration and cell identity fencing. |
+
+The prior branch at `c69b5e5` is a reference implementation for the pure core, privacy bounds, and Jupyter formatter. Selectively transplant those parts with `apply_patch` and reconcile against current master. Do not copy its `prototype_runtime.py`, `runtime_api.py`, obsolete tests, or old orchestration.
+
+---
+
+### Task 1: Pure ordered trace and source-map normalizer
+
+**Files:**
+- Modify: `src/onec_runtime/bsl/diagnostics.py`
+- Test: `tests/unit/test_bsl_diagnostics.py`
+- Test: `tests/unit/test_bsl_diagnostic_acceptance.py`
+
+**Interfaces:**
+- Consumes: existing `MappedSource`, `VisibleSourceContext`, `WorkerDiagnosticArtifact` and `parse_platform_diagnostic`.
+- Produces: `DiagnosticTextSpan`, `ParsedDiagnosticCause`, `ParsedDiagnosticFrame`, `ErrorTraceCause`, `ErrorTraceFrame`, `ErrorTraceFrameOrigin`, and `normalize_platform_diagnostic_trace(parsed, *, stage, executed=None, visible_source_context=None, pinned_manifest_sha256=None, pinned_artifacts=()) -> NormalizedDiagnostic`.
+
+- [ ] **Step 1: Add failing parser and mapping tests.** Port the focused RU/EN, nested cause, anonymous, native, line-only, Worker, ambiguous-map and truncation cases from `c69b5e5:tests/unit/test_bsl_diagnostics.py`. Include this small smoke assertion in the current suite:
+
+```python
+raw = "Error getting value\n{Документ.ПриемНаРаботу.МодульОбъекта(15)}:Вызвать();\nReason:\nUninitialized value"
+parsed = parse_platform_diagnostic(raw)
+assert len(parsed.causes) == 2
+assert parsed.frames[0].location.module_name == "Документ.ПриемНаРаботу.МодульОбъекта"
+assert parsed.frames[0].location.column is None
+assert parsed.platform_diagnostic == raw
+```
+
+- [ ] **Step 2: Verify red.** Run `uv run --group dev python -m pytest tests/unit/test_bsl_diagnostics.py tests/unit/test_bsl_diagnostic_acceptance.py -q`; expect the new trace assertions to fail because master lacks `causes` and `frames`.
+- [ ] **Step 3: Port only the pure core.** Bring the trace dataclasses, bounded structural parser and per-frame mapping helpers from `c69b5e5:src/onec_runtime/bsl/diagnostics.py` into the current file. Keep the public call shape:
+
+```python
+def normalize_platform_diagnostic_trace(
+    parsed: ParsedPlatformDiagnostic,
+    *,
+    stage: DiagnosticStage,
+    executed: MappedSource | None = None,
+    visible_source_context: VisibleSourceContext | None = None,
+    pinned_manifest_sha256: str | None = None,
+    pinned_artifacts: tuple[WorkerDiagnosticArtifact, ...] = (),
+) -> NormalizedDiagnostic:
+    if not isinstance(parsed, ParsedPlatformDiagnostic):
+        raise ValueError("parsed must be a ParsedPlatformDiagnostic")
+    if type(stage) is not DiagnosticStage:
+        raise ValueError("stage must be a DiagnosticStage")
+    if executed is not None and not isinstance(executed, MappedSource):
+        raise ValueError("executed must be a MappedSource or None")
+    if visible_source_context is not None and not isinstance(
+        visible_source_context, VisibleSourceContext,
+    ):
+        raise ValueError("visible_source_context must be a VisibleSourceContext")
+    if executed is None and visible_source_context is not None:
+        raise ValueError("visible source context requires an executed artifact")
+    if pinned_manifest_sha256 is not None and type(pinned_manifest_sha256) is not str:
+        raise ValueError("pinned manifest identity must be a string or None")
+    if type(pinned_artifacts) is not tuple:
+        raise ValueError("pinned artifacts must be an immutable tuple")
+    if pinned_manifest_sha256 is None and pinned_artifacts:
+        raise ValueError("pinned artifacts require a manifest identity")
+    if pinned_manifest_sha256 is not None:
+        _validate_worker_diagnostic_request(
+            parsed, pinned_manifest_sha256, pinned_artifacts,
+        )
+    if pinned_manifest_sha256 is not None and (
+        executed is None
+        or (
+            bool(parsed.locations)
+            and parsed.locations[0].worker_artifact_location is not None
+        )
+    ):
+        base = _remap_worker_runtime_primary(
+            parsed, stage=stage,
+            pinned_manifest_sha256=pinned_manifest_sha256,
+            pinned_artifacts=pinned_artifacts,
+        )
+    elif executed is not None:
+        base = _remap_platform_primary(
+            parsed, executed, stage=stage,
+            visible_source_context=visible_source_context,
+        )
+    else:
+        base = _generic_trace_base(parsed, stage)
+    causes = tuple(
+        ErrorTraceCause(
+            item.ordinal, item.summary_span, item.block_span,
+            item.frame_ordinals, item.category,
+        )
+        for item in parsed.causes
+    )
+    frames, worker_frames = _normalize_trace_frames(
+        parsed, executed=executed,
+        visible_source_context=visible_source_context,
+        pinned_manifest_sha256=pinned_manifest_sha256,
+        pinned_artifacts=pinned_artifacts,
+    )
+    return replace(
+        base, causes=causes, frames=frames,
+        frames_truncated=parsed.frames_truncated,
+        causes_truncated=parsed.causes_truncated,
+        worker_frames=(
+            base.worker_frames
+            if executed is None and pinned_manifest_sha256 is not None
+            else worker_frames
+        ),
+    )
+```
+
+The body is the corresponding tested implementation from commit `c69b5e5`, not a new runtime lookup. Preserve the old single-primary `remap_platform_diagnostic` and `remap_worker_stage_diagnostic` behavior while adding ordered trace fields. The UTF-8 limiter runs before structural parsing and hashes the full input.
+- [ ] **Step 4: Verify green.** Run the two focused modules again and `uv run --group dev python -m pytest tests/unit/test_worker_universe.py -q`; inspect any failures caused by the new trace fields before moving on.
+- [ ] **Step 5: Commit.** Stage only the three files above and commit `feat: port bounded BSL diagnostic trace core` after `git diff --check`.
+
+### Task 2: Contract validation and verbatim private evidence
+
+**Files:**
+- Modify: `src/onec_runtime/runtime_contracts.py`
+- Modify: `src/onec_runtime/privacy.py`
+- Modify: `packages/mcp/src/onec_runtime_mcp/agent/operations.py` and `packages/mcp/src/onec_runtime_mcp/server.py` only where the existing private/expert validators still impose 4 KiB or rewrite 1C text
+- Test: `tests/unit/test_runtime_contract_boundaries.py`
+- Test: `tests/unit/test_mcp_profiles.py`
+- Test: `tests/unit/test_mcp_server.py`
+- Test: `tests/unit/test_agent_operation_view.py`
+
+**Interfaces:**
+- Consumes: Task 1 trace dataclasses and `NormalizedDiagnostic`.
+- Produces: `MAX_PRIVATE_DIAGNOSTIC_BYTES = 65_536`; `sanitize_normalized_diagnostic(value) -> NormalizedDiagnostic | None` validates every cause/frame/span; `bounded_platform_diagnostic(value: str | None, *, truncated: bool, redacted: bool) -> tuple[str | None, bool, bool]` preserves UTF-8-bounded private text verbatim.
+
+- [ ] **Step 1: Add failing boundary tests.** Transfer the trace validation cases from `c69b5e5:tests/unit/test_runtime_contract_boundaries.py` and test multibyte truncation and unchanged public keys:
+
+```python
+raw = "Ж" * 40_000
+bounded, truncated, redacted = bounded_platform_diagnostic(
+    raw, truncated=False, redacted=False,
+)
+assert len(bounded.encode("utf-8")) <= 65_536
+assert truncated is True
+assert redacted is False
+assert bounded == "Ж" * (65_536 // 2)
+```
+
+- [ ] **Step 2: Verify red.** Run `uv run --group dev python -m pytest tests/unit/test_runtime_contract_boundaries.py tests/unit/test_mcp_profiles.py tests/unit/test_mcp_server.py tests/unit/test_agent_operation_view.py -q`; the 4 KiB master bound must fail the new assertion.
+- [ ] **Step 3: Port validation and bound.** Reuse `c69b5e5` validation rules in `runtime_contracts.py`; reject wrong nested types, nonmonotonic spans, impossible origin/mapping combinations, oversized text and frame/cause counts without raising. In `privacy.py`, replace the expert-text rewrite with byte-bounded verbatim slicing while leaving public wire keys unchanged:
+
+```python
+encoded = value.encode("utf-8")
+bounded = encoded[:MAX_PRIVATE_DIAGNOSTIC_BYTES].decode("utf-8", errors="ignore")
+return bounded, truncated or len(encoded) > MAX_PRIVATE_DIAGNOSTIC_BYTES, redacted
+```
+
+- [ ] **Step 4: Verify green.** Run the Task 2 tests plus `tests/unit/test_bsl_diagnostics.py`; ensure public serialization still omits platform text and source strings. If the existing MCP expert validator has a 4 KiB cap, adjust that validator to `MAX_PRIVATE_DIAGNOSTIC_BYTES`; keep the exact existing wire key set and do not add an MCP expert tool.
+- [ ] **Step 5: Commit.** Stage only touched Task 2 files and commit `feat: validate bounded private BSL trace evidence` after `git diff --check`.
+
+### Task 3: Read Worker evidence from the existing operation pin
+
+**Files:**
+- Modify: `src/onec_runtime/worker_universe.py`
+- Modify: `src/onec_runtime/execution/worker_activation.py`
+- Modify: `src/onec_runtime/execution/controller/controller.py`
+- Modify: `src/onec_runtime/execution/reply_publication.py` (optional evidence fields only)
+- Test: `tests/unit/test_worker_universe.py`
+- Test: `tests/unit/test_execution_controller_routes.py`
+- Test: `tests/unit/test_execution_reply_publication.py`
+
+**Interfaces:**
+- Consumes: `OperationGenerationPin`, its manifest and retained `WorkerGenerationDebugView`.
+- Produces: `WorkerUniverseRegistry.diagnostic_artifacts_for_pin(pin: OperationGenerationPin) -> tuple[WorkerDiagnosticArtifact, ...]`. Confirmed failed `MainYield`, `MainConfirmedDecodeFailure`, and `CaptureRemoteOutcome` carry optional `pinned_manifest_sha256` and `pinned_artifacts` fields with empty defaults; successful outcomes leave defaults untouched.
+
+- [ ] **Step 1: Add a pin-fencing regression.** Extend `test_old_generation_debug_view_lives_until_last_pin_release` in `test_worker_universe.py`. After promoting generation 2 while holding generation 1's pin, assert:
+
+```python
+evidence = host.diagnostic_artifacts_for_pin(pin)
+assert evidence
+assert {item.manifest_sha256 for item in evidence} == {first.manifest.sha256}
+assert {item.registration_name for item in evidence} == {
+    module.registration_name for module in first.manifest.modules
+}
+```
+
+Also assert a released pin raises `ProtocolError`, and add controller spies showing evidence retrieval is zero for success and exactly once for a failed MAIN/CAPTURE result.
+- [ ] **Step 2: Verify red.** Run `uv run --group dev python -m pytest tests/unit/test_worker_universe.py tests/unit/test_execution_controller_routes.py tests/unit/test_execution_reply_publication.py -q`; expect the new pin method and outcome fields to be absent.
+- [ ] **Step 3: Add the read-only pin adapter.** Under the registry's existing lease validation, convert the retained debug view and its matching manifest descriptors:
+
+```python
+view = self._operation_debug_view(pin)
+return tuple(
+    WorkerDiagnosticArtifact(
+        logical_name=descriptor.logical_name,
+        revision=descriptor.revision,
+        artifact_sha256=module.artifact_sha256,
+        registration_name=descriptor.registration_name,
+        manifest_sha256=view.manifest.sha256,
+        source_map_sha256=module.source_map_sha256,
+        mapped_source=module.mapped_source,
+        visible_source_context=module.visible_context,
+    )
+    for descriptor, module in zip(view.manifest.modules, view.modules, strict=True)
+)
+```
+
+`WorkerUniverseActivationAdapter` accepts its own `_GenerationLease`, checks `lease.pin` is present, and delegates to the registry. Do not call `pin_active` again.
+- [ ] **Step 4: Carry evidence only on confirmed error.** In controller MAIN completion (including `MainConfirmedDecodeFailure` after CAPTURE) use `_main_worker_leases[operation.command_id]`; in the CAPTURE ticket use the existing local `lease` before its dependent release ticket. Set the optional outcome fields only when the remote error string is nonempty or `EvaluationResult.error_occurred` is true. On any evidence failure leave the fields empty; do not fail the confirmed cell. A compact adapter boundary is:
+
+```python
+if remote_error and lease is not None and lease.pin is not None:
+    manifest_sha256 = lease.pin.handle.manifest_sha256
+    pinned_artifacts = activation.diagnostic_artifacts_for_lease(lease)
+```
+
+- [ ] **Step 5: Verify green and commit.** Run the three Task 3 modules plus `tests/unit/test_runtime_rdbg_single_owner.py`; commit `feat: retain exact Worker diagnostic evidence on failures` after `git diff --check`.
+
+### Task 4: Publish full diagnostics for MAIN and CAPTURE failures
+
+**Files:**
+- Modify: `src/onec_runtime/execution/reply_publication.py`
+- Test: `tests/unit/test_execution_reply_publication.py`
+- Test: `tests/unit/test_cell_execution_pipeline.py`
+- Test: `tests/unit/test_capture_stop_recovery_component.py`
+
+**Interfaces:**
+- Consumes: Task 1 `normalize_platform_diagnostic_trace`; Task 3 optional pinned evidence in confirmed outcomes; existing publication records retain the executed source and visible context.
+- Produces: failed `RuntimeReply.diagnostic` with ordered causes/frames while `RuntimeReply.error`, `succeeded`, operation phase and cleanup remain unchanged.
+
+- [ ] **Step 1: Add failing publication tests.** Extend existing MAIN completion and CAPTURE result tests with a native frame followed by a mapped notebook frame, a native-only failure with no `executed_source`, and a late MAIN error after CAPTURE. Assert both mixed frames survive in platform order and that diagnostic failure does not mask the BSL failure:
+
+```python
+assert reply.succeeded is False
+assert reply.error == "BSL execution failed"
+assert [frame.origin.value for frame in reply.diagnostic.frames] == [
+    "native_module", "executed_artifact",
+]
+```
+
+Spy on `parse_platform_diagnostic` and the Worker evidence collaborator in success cases; assert both have zero calls.
+- [ ] **Step 2: Verify red.** Run `uv run --group dev python -m pytest tests/unit/test_execution_reply_publication.py tests/unit/test_cell_execution_pipeline.py tests/unit/test_capture_stop_recovery_component.py -q`; the new trace and success-path assertions must fail before the publisher change.
+- [ ] **Step 3: Replace only the error path.** Keep `_execution_diagnostic` in `reply_publication.py` pure and error-gated. Parse even when `source is None`, so native frames remain visible; only an empty error returns `None` before parsing. Its failure body calls:
+
+```python
+return normalize_platform_diagnostic_trace(
+    parse_platform_diagnostic(error),
+    stage=DiagnosticStage.EXECUTION,
+    executed=source,
+    visible_source_context=visible,
+    pinned_manifest_sha256=pinned_manifest_sha256,
+    pinned_artifacts=pinned_artifacts,
+)
+```
+
+Wrap only diagnostic enrichment in a failure-isolation guard that returns `None`; do not alter MAIN/CAPTURE success, result decoding, ledger settlement, or pin release. The existing Worker stage-error path in `worker_universe.py` uses the Task 1 parser without a second RDBG operation.
+- [ ] **Step 4: Verify green and commit.** Run the three Task 4 modules plus `tests/unit/test_worker_universe.py` and `tests/unit/test_runtime_contract_boundaries.py`; commit `feat: publish mapped MAIN and CAPTURE error stacks` after `git diff --check`.
+
+### Task 5: Render detailed trace in Jupyter and optional source links
+
+**Files:**
+- Create: `packages/jupyter/src/onec_runtime_jupyter/diagnostic_trace.py`
+- Create: `packages/jupyter/src/onec_runtime_jupyter/diagnostic_sources.py`
+- Modify: `packages/jupyter/src/onec_runtime_jupyter/extension.py`
+- Test: `tests/unit/test_jupyter_adapter.py`
+- Test: `tests/unit/test_runtime_source_root_config.py`
+
+**Interfaces:**
+- Consumes: validated `NormalizedDiagnostic`, current cell `SourceUnitRef` and source text, optional configured source root.
+- Produces: `render_error_trace(diagnostic, *, heading, visible_source, source_unit, source_root=None) -> str | None` for human display only, and `DiagnosticSourceFiles.line_excerpt(frame: ErrorTraceFrame, platform_detail: str | None) -> str | None` for a matched local line. Public JSON remains compact; diagnostic mode retains bounded original 1C text.
+
+- [ ] **Step 1: Add failing adapter tests.** Port display/fence cases from `c69b5e5:tests/unit/test_jupyter_adapter.py`. Assert Russian/English causes, ordered native and mapped frames, explicit platform fragment, raw text in diagnostic mode, no raw text in public payload, stale source hash suppression, and optional root hint. For a native local excerpt, require its stripped line to match the 1C detail fragment; a divergent local export keeps the platform fragment but shows no local excerpt. A minimal text assertion is:
+
+```python
+assert "Причины:" in display.text
+assert "Стек (1С):" in display.text
+assert "фрагмент 1С:" in display.text
+assert "Исходное сообщение 1С:" in display.text
+assert "platform_diagnostic" not in display.payload.get("diagnostic", {})
+```
+
+- [ ] **Step 2: Verify red.** Run `uv run --group dev python -m pytest tests/unit/test_jupyter_adapter.py tests/unit/test_runtime_source_root_config.py -q`; new trace-rendering assertions must fail.
+- [ ] **Step 3: Port the two small helpers.** Adapt `c69b5e5:packages/jupyter/src/onec_runtime_jupyter/diagnostic_trace.py` and `diagnostic_sources.py` with `apply_patch`. Continue to validate through `sanitize_normalized_diagnostic`, verify `source_sha256(visible_source) == source_unit.source_sha256` before displaying an original line, and use `ConfigurationSourceLayout.safe_path` for optional file hints. Native frames display 1C coordinates and detail without a root. A local file line is labelled as a local export and shown only if it matches the stripped 1C detail fragment; otherwise show only the platform fragment. A local file mismatch removes only the optional hint or excerpt:
+
+```python
+detail = _span_text(evidence, frame.detail_span)
+try:
+    hint = source_files.hint(frame) if source_files is not None else None
+    local_line = (
+        source_files.line_excerpt(frame, detail)
+        if source_files is not None else None
+    )
+except BaseException:
+    hint = None
+    local_line = None
+```
+
+The helper's native line check uses the already resolved relative hint, not a
+second search:
+
+```python
+relative = self.hint(frame)
+if relative is None or platform_detail is None:
+    return None
+path = self.layout.safe_path(self.layout.normalized_root / relative)
+lines = path.read_text(encoding="utf-8-sig").splitlines()
+line = frame.platform_location.line
+if not 1 <= line <= len(lines):
+    return None
+local = lines[line - 1].strip()
+return local if local and local == platform_detail.strip() else None
+```
+
+- [ ] **Step 4: Integrate at the current display boundary.** Call `render_error_trace` only after a failed `RuntimeReply` has passed source-unit fencing in `extension.py`; use the session's configured capture source root when present. Keep Python `_render_traceback_` compact and do not include raw text in the public MIME payload.
+- [ ] **Step 5: Verify green and commit.** Run Task 5 tests plus `tests/unit/test_jupyter_capture_display.py`; commit `feat: show full mapped BSL trace in notebooks` after `git diff --check`.
+
+### Task 6: Regression and live qualification
+
+**Files:**
+- Test: `tests/integration/test_worker_universe_1c.py` only if an opt-in fixture needs a compact assertion; do not save raw live evidence.
+- Modify: `docs/superpowers/specs/2026-09-18-bsl-error-diagnostics-main-design.md` only to record measured deviations from the approved design.
+
+**Interfaces:**
+- Consumes: Tasks 1–5 completed and committed.
+- Produces: test evidence and a final status report distinguishing static from live qualification.
+
+- [ ] **Step 1: Re-run focused and full static tests.** Run:
+
+```powershell
+uv run --group dev python -m pytest tests/unit/test_bsl_diagnostics.py tests/unit/test_execution_reply_publication.py tests/unit/test_jupyter_adapter.py tests/unit/test_worker_universe.py -q
+uv run --group dev python -m pytest tests/unit -q
+```
+
+- [ ] **Step 2: Check adjacent adapter and contract behavior.** Run `uv run --group dev python -m pytest tests/unit/test_mcp_profiles.py tests/unit/test_mcp_server.py tests/unit/test_agent_operation_view.py tests/unit/test_runtime_contract_boundaries.py -q`. Check `git diff --check`, `git status --short`, and the exact changed-file list against the ownership map. Do not add an MCP expert tool/schema.
+- [ ] **Step 3: Qualify against 1C only when available.** Use the repository's existing opt-in live harness with disposable infobases. Exercise Russian/English failures, nested causes, MAIN completion after CAPTURE, CAPTURE failure then successful retry, and a successful-cell diagnostic-call spy. Keep platform output outside the repository; if the platform is unavailable, report live qualification as not run rather than passing.
+- [ ] **Step 4: Review and hand off.** Request code review, resolve findings with focused reruns, then report commits, test counts, live results or limitation, and the remaining deferred MCP expert issue. Do not merge master without a separate request.

onec_interactive_runtime_core-0.1.21/docs/superpowers/plans/2026-09-20-bsl-error-diagnostics-release.md

@@ -0,0 +1,227 @@
+# BSL Error Diagnostics v0.1.21 Release Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Publish the source-mapped BSL error diagnostics on `master` as `v0.1.21`, including verified runtime-core and Jupyter packages on PyPI.
+
+**Architecture:** Prepare one metadata-only release commit in an isolated worktree, prove the resulting source and binary distributions locally, then publish the exact commit through the existing GitHub Release and PyPI Trusted Publishing workflow. The MCP workspace package remains version-aligned but is not uploaded, matching the established release boundary.
+
+**Tech Stack:** Git, Python 3.12+, uv, pytest, npm, GitHub CLI, GitHub Actions, PyPI Trusted Publishing.
+
+**Spec:** `docs/superpowers/specs/2026-09-20-bsl-error-diagnostics-release-design.md`
+
+## Global Constraints
+
+- Release version is exactly `0.1.21`; tag is exactly `v0.1.21`.
+- Release base is `master` commit `86b7972`.
+- Publish only `onec-interactive-runtime-core` and `onec-interactive-jupyter` to PyPI.
+- Keep `onec-interactive-mcp` version-aligned in the workspace but unpublished.
+- Keep the VS Code extension at `0.1.4` and the product 1C extension artifact/protocol unchanged.
+- Do not add the deferred MCP expert diagnostic contract.
+- Do not commit credentials, live evidence, local paths, generated environments, or built artifacts.
+- Preserve the user's existing checkout and uncommitted notebook edits.
+
+## Review Focus
+
+- A stale `0.1.20` package version or exact dependency would produce inconsistent wheels; the version-consistency and packaging checks must catch it.
+- A README-wide replacement could incorrectly change the VSIX release/version; inspect the final README diff explicitly.
+- A tag not reachable from `master` would fail the workflow ancestor gate; verify `origin/master` equals the tagged commit before release publication.
+- A partial PyPI publication must be retried from the same immutable tag and artifacts; never rebuild under `0.1.21` after one package is uploaded.
+- A local install can accidentally resolve packages from the public index; local artifact installation must use `--no-index`, and the final public verification must use a fresh environment and the PyPI index.
+
+---
+
+### Task 1: Prepare the metadata-only release commit
+
+**Files:**
+- Create: `docs/superpowers/specs/2026-09-20-bsl-error-diagnostics-release-design.md`
+- Create: `docs/superpowers/plans/2026-09-20-bsl-error-diagnostics-release.md`
+- Modify: `pyproject.toml`
+- Modify: `src/onec_runtime/__init__.py`
+- Modify: `packages/jupyter/pyproject.toml`
+- Modify: `packages/jupyter/src/onec_runtime_jupyter/__init__.py`
+- Modify: `packages/jupyter/frontend/package.json`
+- Modify: `packages/jupyter/frontend/package-lock.json`
+- Modify: `packages/mcp/pyproject.toml`
+- Modify: `packages/mcp/src/onec_runtime_mcp/__init__.py`
+- Modify: `uv.lock`
+- Modify: `README.md`
+- Test: `tests/packaging/test_product_wheels.py`
+
+**Interfaces:**
+- Consumes: the version fields and exact dependency pins currently set to `0.1.20`.
+- Produces: a single internally consistent `0.1.21` source tree suitable for the existing release workflow.
+
+- [ ] **Step 1: Confirm the release preconditions**
+
+Run a read-only script that asserts every product version and exact dependency
+pin is `0.1.20`, `v0.1.21` is absent locally and remotely, `master` and
+`origin/master` both equal `86b7972`, and PyPI reports `0.1.20` as the latest
+core and Jupyter release.
+
+Expected: all assertions pass and no release state is changed.
+
+- [ ] **Step 2: Update all release metadata to `0.1.21`**
+
+Change only the files listed above. In README, update the source release link,
+the stated Python package version, and the installation pin to `0.1.21`; leave
+the VSIX reference at `v0.1.18` / `0.1.4`.
+
+- [ ] **Step 3: Regenerate lock metadata**
+
+Run: `uv lock --offline`
+
+Expected: only the three workspace package versions and their exact core pins
+move to `0.1.21`; third-party dependency resolutions do not change.
+
+- [ ] **Step 4: Verify metadata consistency and the README diff**
+
+Run a Python script that loads the three `pyproject.toml` files, the two Python
+`__version__` declarations, the frontend `package.json`/`package-lock.json`,
+and `uv.lock`, and asserts version `0.1.21` everywhere. Assert Jupyter and MCP
+both require `onec-interactive-runtime-core==0.1.21`. Inspect
+`git diff -- README.md` and confirm the VSIX reference is unchanged.
+
+Expected: every assertion passes; no stale product `0.1.20` remains outside
+historical release documents/specifications.
+
+- [ ] **Step 5: Run the focused metadata/packaging gate**
+
+Run: `uv run --group dev python -m pytest tests/packaging/test_product_wheels.py -q`
+
+Expected: all 12 packaging tests pass.
+
+- [ ] **Step 6: Commit the release candidate**
+
+Run `git diff --check`, inspect the complete changed-file list, then commit
+with message `chore: prepare v0.1.21 release`.
+
+Expected: one release commit on top of `86b7972`, with no generated artifacts
+or local paths tracked.
+
+### Task 2: Qualify the exact release candidate
+
+**Files:**
+- Read: `.github/workflows/releases.yaml`
+- Read: `tests/packaging/test_product_wheels.py`
+- Verify: built wheel and sdist artifacts outside the tracked tree
+
+**Interfaces:**
+- Consumes: the committed, version-consistent `0.1.21` source tree from Task 1.
+- Produces: test output and local package artifacts proving the exact commit is publishable.
+
+- [ ] **Step 1: Run the offline unit gate**
+
+Run: `uv run --group dev python -m pytest tests/unit -q`
+
+Expected: the full offline unit suite passes; conditional skips are reported
+separately and are not described as live qualification.
+
+- [ ] **Step 2: Verify the Jupyter frontend**
+
+Run:
+
+```powershell
+npm --prefix packages/jupyter/frontend ci
+npm --prefix packages/jupyter/frontend test
+npm --prefix packages/jupyter/frontend run build
+```
+
+Expected: dependency installation, frontend tests, TypeScript compilation,
+and JupyterLab extension build all succeed.
+
+- [ ] **Step 3: Verify the bundled 1C extension is unchanged and current**
+
+Run: `uv run --group dev python -m pytest tests/unit/test_universal_extension_source.py::test_checked_in_bundle_matches_canonical_source_and_manifest -q`
+
+Expected: one test passes.
+
+- [ ] **Step 4: Build the exact publishable artifacts**
+
+Create a fresh temporary output directory outside the tracked tree, then run:
+
+```powershell
+uv build --package onec-interactive-runtime-core --no-sources --out-dir $releaseArtifacts
+uv build --package onec-interactive-jupyter --no-sources --out-dir $releaseArtifacts
+```
+
+Expected: exactly one wheel and one sdist for each published package, all with
+version `0.1.21`; no MCP distribution is present.
+
+- [ ] **Step 5: Inspect and install the local artifacts without an index**
+
+Check wheel METADATA, filenames, bundled extension files, and Jupyter frontend
+assets. Create a fresh temporary virtual environment and install
+`onec-interactive-jupyter==0.1.21` with `--no-index --find-links
+$releaseArtifacts`. Import both packages and assert their distribution and
+module versions are exactly `0.1.21`.
+
+Expected: the clean installation succeeds using only the four local artifacts.
+
+- [ ] **Step 6: Verify the branch is publication-ready**
+
+Run `git diff --check`, `git status --short --branch`, and compare `HEAD` with
+`86b7972`. Confirm there is exactly one release commit and the worktree is
+clean. Prepare release notes that report the fresh test counts and clearly
+label the previously completed disposable-infobase checks as earlier live
+qualification of the runtime commit.
+
+Expected: clean branch, exact release notes, and no untracked artifacts.
+
+### Task 3: Publish and verify `v0.1.21`
+
+**Files:**
+- Publish: Git commit, annotated Git tag, GitHub Release, PyPI distributions
+- Verify: GitHub Actions run and PyPI JSON/file metadata
+
+**Interfaces:**
+- Consumes: the exact verified Task 2 commit and release notes.
+- Produces: public GitHub release `v0.1.21` and PyPI core/Jupyter `0.1.21` distributions.
+
+- [ ] **Step 1: Recheck remote state immediately before publication**
+
+Fetch `origin`, assert `origin/master` is still `86b7972`, confirm tag/release
+`v0.1.21` does not exist, and confirm PyPI still has no `0.1.21` files.
+
+Expected: no concurrent release or master update has appeared.
+
+- [ ] **Step 2: Push the verified commit and tag**
+
+Push `HEAD` to `origin/master`, verify the remote SHA, create annotated tag
+`v0.1.21` with message `Release v0.1.21`, and push that tag.
+
+Expected: `origin/master`, local `HEAD`, and `v0.1.21^{commit}` are identical.
+
+- [ ] **Step 3: Publish the GitHub Release**
+
+Create a non-draft, non-prerelease GitHub Release named
+`v0.1.21 - source-mapped BSL diagnostics` from the verified existing tag and
+the prepared release notes.
+
+Expected: the release is public and triggers `.github/workflows/releases.yaml`.
+
+- [ ] **Step 4: Monitor Trusted Publishing to completion**
+
+Locate the release-triggered workflow run and watch it until the build,
+`publish-core`, and `publish-jupyter` jobs all complete successfully.
+
+Expected: the workflow conclusion is `success`. If publication is partial,
+retry the same workflow/tag without changing source or artifacts.
+
+- [ ] **Step 5: Verify PyPI and a clean public installation**
+
+Query the official PyPI JSON endpoints and assert both packages report
+`0.1.21`, with one wheel and one sdist each. In a fresh environment, install
+`onec-interactive-jupyter==0.1.21` from PyPI and assert the installed Jupyter
+and core distribution/module versions are `0.1.21`.
+
+Expected: both public packages install and import successfully from PyPI.
+
+- [ ] **Step 6: Record final release state**
+
+Confirm the GitHub Release URL, workflow URL, PyPI project URLs, remote commit,
+and tag. Remove only temporary local environments/artifacts and the isolated
+release worktree after the release is fully verified.
+
+Expected: the public release is reproducible from one tagged release commit,
+and the user's original checkout remains unchanged.