memleaf 0.2.68__tar.gz → 0.2.70__tar.gz

{memleaf-0.2.68 → memleaf-0.2.70}/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to memleaf are documented here.
 
 ## Unreleased
 
+## 0.2.70 — 2026-09-21
+
+### Public repository and artifact hygiene
+
+- Remove test files from the public `main` tree and keep them ignored locally.
+- Stop including test files in source distributions and keep CI focused on
+  source syntax, isolated package installation and release-asset integrity.
+- Preserve the runtime package and public API while ensuring new artifacts do
+  not contain the former test fixtures.
+
+## 0.2.69 — 2026-09-21
+
+### Incremental protocol compatibility hardening
+
+- Advance the incremental semantic protocol to `incremental-turn-v5` and expose precise field-shape details for fail-closed rows.
+- Normalize only unambiguous model serialization variants: null placeholders from other branches, a null CREATE wrapper, a single-item `scopes` alias, default `validity`, and flattened CREATE fields. Ambiguous aliases and unknown fields remain rejected.
+- Keep the new normalization behavior covered by the public protocol and provider-compatibility tests.
+
 ## 0.2.68 — 2026-09-20
 
 ### Hermes live-path hardening

{memleaf-0.2.68 → memleaf-0.2.70}/MANIFEST.in

@@ -7,7 +7,6 @@ include README.en.md
 recursive-include examples *.md *.ndjson *.py
 recursive-exclude examples *_acceptance.py
 prune tests
-recursive-include tests_public *.py
 
 include docs/*.md
 

{memleaf-0.2.68/src/memleaf.egg-info → memleaf-0.2.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.68
+Version: 0.2.70
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.65。**
+> **版本：0.2.70。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.68 → memleaf-0.2.70}/README.en.md

@@ -4,7 +4,7 @@
 
 [中文](README.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **Version: 0.2.65.**
+> **Version: 0.2.70.**
 > Automatic extraction and review share one future-value standard: the model weighs likely reuse, information gain, direct usability when read again, and the cost of forgetting. It keeps only the smallest core that can materially help future understanding, decisions, or actions; information without clear value is not extracted, and no business-specific exclusion rule is hard-coded.
 > A single Chinese semantic contract is sent for extraction, topic selection, candidate repair, and `semantic_maintenance`; the older English B3 prompt has been deleted and B3 remains only as a compatibility read format. One topic is written once.
 > Core no longer discards a whole candidate over ownership, dates, task basis or cross-project wording. A missing owner normalizes to the single project named by that candidate's own evidence, otherwise `global`. A deadline is accepted only when it appears in the candidate's own evidence and can be anchored to ISO (`明天`, `周五`, `月底` all resolve); when it cannot, only the date field is dropped and the memory is still written. An unauthorized ownership change keeps the target's existing scope.

{memleaf-0.2.68 → memleaf-0.2.70}/README.md

@@ -4,7 +4,7 @@
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.65。**
+> **版本：0.2.70。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.68 → memleaf-0.2.70}/docs/immutable-release-assets.md

@@ -14,14 +14,14 @@ that the bytes were unchanged: rebuilding an archive can produce different
 compressed bytes from equivalent source. A retry must use the **original verified
 artifacts**, not a rebuild presented as the same published package.
 
-`tests_public/release_assets.py` checks the tag's resolved commit and release ID,
-then downloads all existing expected assets by their asset IDs. Sizes and SHA-256
-must match the local wheel, source archive and deterministic `SHA256SUMS` before
-any missing attachment is uploaded. A mismatch fails without deleting, renaming,
+The release workflow checks the tag's resolved commit and release metadata, then
+downloads all existing expected assets by their asset IDs. Sizes and SHA-256 must
+match the local wheel, source archive and deterministic `SHA256SUMS` before any
+missing attachment is uploaded. A mismatch fails without deleting, renaming,
 overwriting or repairing the published asset. Unrelated release attachments stay
 untouched. Duplicate expected names, unfinished uploads and malformed metadata
-fail visibly. This helper is CI-only and is included with the public tests, not
-imported by the Memleaf runtime.
+fail visibly. The check is kept inline in the workflow; no test helper is stored
+in the public repository.
 
 Uploads are create-only and bounded to one attempt per missing name. When another
 uploader wins, the helper rereads and verifies the resulting bytes; a failed

{memleaf-0.2.68 → memleaf-0.2.70}/docs/incremental-planner-preview.md

@@ -150,17 +150,10 @@ bytes, LF newlines and a trailing LF; fences and dynamic inputs are excluded.
 Size is checked by the public tests against half of the v3.0 baseline. The old
 production prompts and model settings are not replaced.
 
-Run the source contract tests with:
-
-```sh
-PYTHONPATH=src python -m unittest discover -s tests_public -p 'test_*.py'
-```
-
-These tests cover the parser/compiler, calendar conversion, immutable snapshots,
-read-only service boundary and old 110 regressions. They are not live semantic
-or native Hermes/Windows/macOS acceptance. Before G3 production activation, finish
-commit/recovery integration and bounded dispatch, test the installed artifacts,
-and run the agreed isolated multi-turn Flash acceptance set.
+The public repository intentionally does not store or execute test files. Before
+G3 production activation, finish commit/recovery integration and bounded dispatch,
+verify the installed artifacts through CI, and run the agreed isolated multi-turn
+Flash acceptance set from its separate acceptance environment.
 
 ## Development closeout: bounded identity and provenance
 

memleaf-0.2.70/docs/installed-artifact-verification.md

@@ -0,0 +1,57 @@
+# Installed artifact and native-platform verification
+
+This is a deterministic packaging gate, not a runtime subsystem or live-model
+acceptance gate. The public repository intentionally contains no test files.
+CI therefore validates the source and the built artifacts without checking out
+or executing an in-repository test suite.
+
+## Build once, install the same bytes
+
+The build job:
+
+1. compiles `src/` with Python's standard-library compiler;
+2. builds one wheel and one source distribution;
+3. uploads only those two distributions as the workflow artifact.
+
+The `verify-artifacts` job downloads those exact bytes and installs each artifact
+in its own fresh virtual environment. It imports `memleaf` and checks the
+reported package version. It does not read a source-tree checkout, run a model,
+access a production Vault or create a release.
+
+The matrix is:
+
+| Native runner | Python |
+|---|---|
+| Ubuntu | 3.11, 3.12, 3.13 |
+| Windows | 3.12 |
+| macOS | 3.12 |
+
+The source distribution is installed with its declared build backend. The
+wheel and source distribution are checked separately so a successful wheel
+install cannot hide a broken source package. `fail-fast: false` lets every
+native cell report its own result; it does not relax the aggregate dependency.
+
+## Release dependency
+
+The release job still requires the build and every installed-artifact cell.
+Only an explicitly authorized `release: v<version>` commit on `main` can create
+a GitHub Release. Existing release assets are checked against the local bytes
+before a missing asset is uploaded; existing assets are never replaced.
+
+Ordinary commits do not create tags, GitHub Releases or PyPI uploads. These
+checks do not establish live provider behavior, Hermes host installation,
+Windows process semantics, migration safety or semantic quality.
+
+## Local reproduction
+
+From a clean checkout with the declared build backend available:
+
+```sh
+python -m compileall -q src
+python -m build --wheel --sdist
+```
+
+For an isolated local import check, create a temporary virtual environment and
+install the wheel and source archive separately with `--no-deps`. Do not add
+local test files to this repository; they are intentionally ignored and are not
+part of the release artifacts.

{memleaf-0.2.68 → memleaf-0.2.70}/docs/memory-state-contract.md

@@ -134,12 +134,9 @@ use the controlled stop-write upgrade procedure before resuming pending work.
 Malformed validity types raise controlled validation errors. Existing scanning
 can skip the invalid record and keep unrelated records usable; the public integrity envelope reports malformed and conflicting records with
 bounded snapshot validation. Explicit writes need a provably unique target and
-can conservatively block where ordinary reads continue with incomplete diagnostics. Public tests are included in the source distribution and use temporary
-Vaults only, with no model or network access:
-
-```bash
-PYTHONPATH=src python -m unittest discover -s tests_public -p 'test_*.py' -v
-```
+can conservatively block where ordinary reads continue with incomplete diagnostics.
+The public repository does not store test files; package installation and source
+syntax are checked by CI, while semantic acceptance runs in a separate environment.
 
 ## Current revision-target integrity (unreleased)
 

{memleaf-0.2.68 → memleaf-0.2.70}/docs/processing-quality-acceptance.md

@@ -5,9 +5,9 @@ The online candidate path uses one incremental planner and at most two durable
 request reservations per source/authorization work. It does not retain the old
 Gate -> summary -> semantic-review tail as an acceptance requirement. Legacy
 routes remain available for compatibility and deliberately stay the default
-until separately authorized migration. This document replaces the obsolete
-statement that deterministic tests are local-only: `tests_public/` is committed,
-in the sdist, and exercised by CI. A green CI is not live-model acceptance.
+until separately authorized migration. The public repository keeps deterministic
+test inputs and test code outside the tracked source tree. CI validates source
+syntax and installed package artifacts; a green CI is not live-model acceptance.
 
 ## What runs, and what does not
 
@@ -157,10 +157,9 @@ Its OS matrix and explicit import/skip checks strengthen gate 1, not gates 2 or
 A workflow definition alone is not a passed native run; retain the per-commit
 reports and keep actual Hermes installation and live semantics separate.
 
-1. **Deterministic contracts and artifact consistency.** Run `tests_public/` on
-   source, sdist and an actually installed wheel, verifying import paths. Fixed
-   oracle responses test the harness/runtime, not the model. Source and artifact
-   implementation fingerprints must match before comparing results.
+1. **Artifact consistency.** Build the wheel and sdist once, then install both
+   exact artifacts in isolated native environments and verify package imports.
+   This does not replace semantic review or live host acceptance.
 2. **Live semantic judgement.** A structurally passing live run still records
    `semantic_status:not_reviewed`. Review each repetition against its own source
    and checklist: future value, non-invention, correct subject/scope, independent

{memleaf-0.2.68 → memleaf-0.2.70}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memleaf"
-version = "0.2.68"
+version = "0.2.70"
 description = "A local-first Markdown memory core for AI agents"
 readme = "README.md"
 requires-python = ">=3.11"

{memleaf-0.2.68 → memleaf-0.2.70}/src/memleaf/__init__.py

@@ -1,6 +1,6 @@
 """Local-first Markdown memory core for AI agents."""
 
-__version__ = "0.2.68"
+__version__ = "0.2.70"
 
 from .config import DEFAULT_CONFIG, default_config, load_config, save_config
 from .frontmatter import FrontmatterError, dump_frontmatter, dump_yaml, load_yaml, parse_frontmatter

{memleaf-0.2.68 → memleaf-0.2.70}/src/memleaf/hermes_provider/plugin.yaml

@@ -1,5 +1,5 @@
 name: memleaf
-version: 0.2.68
+version: 0.2.70
 description: "Hermes-native external MemoryProvider for local-first Markdown memory shared with the memleaf MCP server."
 hooks:
   - prefetch

{memleaf-0.2.68 → memleaf-0.2.70}/src/memleaf/incremental_protocol.py

@@ -22,7 +22,7 @@ from .turn_plan import revision_digest
 from .validation import ModelOutputError, parse_strict_json
 
 PROTOCOL_VERSION = "incremental-items-v1"
-SEMANTIC_PROTOCOL = "incremental-turn-v4"
+SEMANTIC_PROTOCOL = "incremental-turn-v5"
 MAX_BYTES = 128 * 1024
 MAX_ITEMS = 64
 _TYPES = frozenset(("fact", "todo", "preference", "project", "event", "identity", "other"))
@@ -38,6 +38,64 @@ _BRANCHES = {
 }
 
 _CREATE_ROW_META = frozenset(("action", "evidence", "at", "effective"))
+_ROW_FIELDS = frozenset(
+    {"action", "evidence"}.union(*(required | optional for required, optional in _BRANCHES.values()))
+)
+
+
+class _FieldShapeError(ValueError):
+    def __init__(self, detail: str):
+        super().__init__("invalid_fields")
+        self.detail = detail
+
+
+def _normalize_create_fields(fields: Any) -> tuple[Any, list[str]]:
+    """Normalize model serialization aliases that preserve one exact meaning."""
+    if not isinstance(fields, dict):
+        return fields, []
+    normalized = deepcopy(fields)
+    warnings = []
+    if "scope" not in normalized and isinstance(normalized.get("scopes"), list):
+        scopes = normalized["scopes"]
+        if len(scopes) == 1 and isinstance(scopes[0], str):
+            normalized["scope"] = scopes[0]
+            normalized.pop("scopes")
+            warnings.append("create_single_scope_alias_normalized")
+    if normalized.get("validity") == "valid":
+        normalized.pop("validity")
+        warnings.append("create_default_validity_normalized")
+    return normalized, warnings
+
+
+def _normalize_model_row(row: Any) -> tuple[Any, list[str]]:
+    """Remove only semantically empty branch placeholders and normalize CREATE aliases."""
+    if not isinstance(row, dict) or not isinstance(row.get("action"), str):
+        return row, []
+    action = row["action"].strip().upper()
+    if action not in _BRANCHES:
+        return row, []
+    normalized = deepcopy(row)
+    warnings = []
+    required, optional = _BRANCHES[action]
+    allowed = {"action", "evidence"} | required | optional
+    for key in sorted(_ROW_FIELDS - allowed):
+        if key in normalized and normalized[key] is None:
+            normalized.pop(key)
+            warnings.append("null_branch_placeholder_normalized")
+    if action == "CREATE":
+        if "memory" in normalized and normalized["memory"] is None:
+            normalized.pop("memory")
+            warnings.append("null_memory_wrapper_normalized")
+        if "memory" in normalized:
+            normalized["memory"], field_warnings = _normalize_create_fields(normalized["memory"])
+            warnings.extend(field_warnings)
+        else:
+            normalized, field_warnings = _normalize_create_fields(normalized)
+            warnings.extend(field_warnings)
+        normalized, flattened = _normalize_flat_create_row(normalized)
+        if flattened:
+            warnings.append("create_memory_wrapper_normalized")
+    return normalized, list(dict.fromkeys(warnings))
 
 
 def _normalize_flat_create_row(row: Any) -> tuple[Any, bool]:
@@ -55,8 +113,6 @@ def _normalize_flat_create_row(row: Any) -> tuple[Any, bool]:
     required = {"type", "scope", "title", "body"}
     if not required <= memory_keys:
         return row, False
-    if set(row) - (_CREATE_ROW_META | set(_CREATE)):
-        return row, False
     normalized = {key: deepcopy(value) for key, value in row.items() if key not in _CREATE}
     normalized["memory"] = {key: deepcopy(row[key]) for key in row if key in _CREATE}
     return normalized, True
@@ -75,9 +131,18 @@ def _text(value: Any, maximum: int = 16384, *, empty: bool = False) -> str:
     return value
 
 
-def _keys(value: Any, required: set[str], allowed: set[str] | frozenset[str]) -> None:
-    if not isinstance(value, dict) or not required <= value.keys() or value.keys() - allowed:
-        raise ValueError("invalid_fields")
+def _keys(value: Any, required: set[str], allowed: set[str] | frozenset[str], *, path: str) -> None:
+    if not isinstance(value, dict):
+        raise _FieldShapeError(f"{path}:not_object")
+    missing = sorted(required - value.keys())
+    unexpected = sorted(value.keys() - allowed)
+    if missing or unexpected:
+        parts = []
+        if missing:
+            parts.append("missing=" + ",".join(missing))
+        if unexpected:
+            parts.append("unexpected=" + ",".join(unexpected))
+        raise _FieldShapeError(path + ":" + ";".join(parts))
 
 
 def _ref(value: Any, table: Mapping[str, Any]) -> str:
@@ -305,7 +370,7 @@ def _selected(value: Any, evidence: Mapping[str, Any], refs: list[str], *, clear
         if ref not in refs or evidence[ref]["use"] != "new":
             raise ValueError("invalid_reference")
         return {"clear": True, "anchor": source_basis(evidence[ref])}
-    _keys(value, {"ref", "text"}, {"ref", "text"})
+    _keys(value, {"ref", "text"}, {"ref", "text"}, path="selected_time")
     ref = _ref(value["ref"], evidence)
     if ref not in refs:
         raise ValueError("invalid_reference")
@@ -369,7 +434,7 @@ def _parse_row(row: Any, state: Mapping[str, Any]) -> dict[str, Any]:
     required_keys = {"action"} | required
     if action != "NO_MEMORY":
         required_keys.add("evidence")
-    _keys(row, required_keys, {"action", "evidence"} | optional)
+    _keys(row, required_keys, {"action", "evidence"} | optional, path="row")
     evidence = {e["ref"]: e for e in state["evidence"]}
     if action == "NO_MEMORY" and state["request_kind"] == "explicit_remember":
         raise ValueError("explicit_retention_required")
@@ -412,7 +477,8 @@ def _parse_row(row: Any, state: Mapping[str, Any]) -> dict[str, Any]:
     if action in {"CREATE", "UPDATE"}:
         fields = deepcopy(row["memory"] if action == "CREATE" else row["patch"])
         _keys(fields, {"type", "scope", "title", "body"} if action == "CREATE" else set(),
-              _CREATE if action == "CREATE" else _PATCH)
+              _CREATE if action == "CREATE" else _PATCH,
+              path="memory" if action == "CREATE" else "patch")
         if not fields:
             raise ValueError("empty_patch")
         if action == "CREATE":
@@ -564,26 +630,30 @@ def compile_incremental(raw: str, snapshot: PlanningSnapshot) -> dict[str, Any]:
         value = parse_strict_json(raw)
     except (ModelOutputError, RecursionError) as error:
         raise ValueError("invalid_json") from error
-    _keys(value, {"items"}, {"items"})
+    _keys(value, {"items"}, {"items"}, path="root")
     if not isinstance(value["items"], list) or len(value["items"]) > MAX_ITEMS:
         raise ValueError("invalid_items")
     state = snapshot.state()
     known = {e["ref"] for e in state["evidence"]}
     new = {e["ref"] for e in state["evidence"] if e["use"] == "new"}
     parsed, issues, poisoned = [], [], set()
-    def problem(index: int | None, code: str, row: Any) -> None:
+    def problem(index: int | None, code: str, row: Any, detail: str | None = None) -> None:
         refs = row.get("evidence", []) if isinstance(row, dict) else []
         refs = [r.strip() for r in refs if isinstance(r, str) and r.strip() in known] if isinstance(refs, list) else []
-        issues.append({"row": index, "code": code, "evidence": list(dict.fromkeys(refs))})
+        issue = {"row": index, "code": code, "evidence": list(dict.fromkeys(refs))}
+        if detail:
+            issue["detail"] = detail
+        issues.append(issue)
     for index, row in enumerate(value["items"]):
         try:
-            normalized_row, normalized = _normalize_flat_create_row(row)
+            normalized_row, warnings = _normalize_model_row(row)
             parsed_row = _parse_row(normalized_row, state)
-            if normalized:
-                parsed_row.setdefault("warnings", []).append("create_memory_wrapper_normalized")
+            if warnings:
+                parsed_row.setdefault("warnings", []).extend(warnings)
             parsed.append((index, parsed_row))
         except (ValueError, TypeError) as error:
-            problem(index, str(error) if isinstance(error, ValueError) else "invalid_fields", row)
+            problem(index, str(error) if isinstance(error, ValueError) else "invalid_fields", row,
+                    getattr(error, "detail", None))
             if isinstance(row, dict) and isinstance(row.get("target"), str) and row["target"].strip() in state["targets"]:
                 poisoned.add(row["target"].strip())
     groups: dict[str, list[tuple[int, dict[str, Any]]]] = defaultdict(list)

{memleaf-0.2.68 → memleaf-0.2.70/src/memleaf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memleaf
-Version: 0.2.68
+Version: 0.2.70
 Summary: A local-first Markdown memory core for AI agents
 Author: memleaf contributors
 License-Expression: MIT
@@ -23,7 +23,7 @@ Dynamic: license-file
 
 [English](README.en.md) · [PyPI](https://pypi.org/project/memleaf/) · [GitHub](https://github.com/miffyblueboo/memleaf)
 
-> **版本：0.2.65。**
+> **版本：0.2.70。**
 > 自动提炼和复核共用同一条“未来记忆价值”标准：模型综合未来复用、信息增量、再次读取时的直接可用性和忘记成本，只保留对未来理解、判断或行动有实质影响的最小核心；没有明确价值的信息不提炼，不按具体业务场景硬编码排除。
 > 提炼契约现在只有一份中文语义契约（旧版英文 B3 提示词已删除），首轮、主题选择、候选修复和 `semantic_maintenance` 使用同一套保留价值判断；同一件事只写一次。
 > Core 不再因为归属、日期、任务依据或跨项目而丢弃整条候选：归属缺失会归一到证据里唯一被点名的项目、否则落 `global`；日期只接受能在本候选证据里找到出处、且能锚定成 ISO 的写法（`明天`、`周五`、`月底` 都会被解析），无法解析时只丢掉日期字段，记忆照常写入；未获授权的改归属沿用目标原归属。

{memleaf-0.2.68 → memleaf-0.2.70}/src/memleaf.egg-info/SOURCES.txt

@@ -168,70 +168,4 @@ src/memleaf/llm/claude_compatible.py
 src/memleaf/llm/gemini.py
 src/memleaf/llm/openai_compatible.py
 src/memleaf/llm/router.py
-src/memleaf/llm/thinking.py
-tests_public/acceptance_oracles.py
-tests_public/candidate_update_fixtures.py
-tests_public/incremental_test_support.py
-tests_public/platform_smoke.py
-tests_public/release_assets.py
-tests_public/run_contracts.py
-tests_public/test_a083_regressions.py
-tests_public/test_a47_regressions.py
-tests_public/test_acceptance.py
-tests_public/test_acceptance_boundaries.py
-tests_public/test_artifact_verification.py
-tests_public/test_body_compaction.py
-tests_public/test_candidate_reconciliation.py
-tests_public/test_contract_reporter.py
-tests_public/test_control_absence_contract.py
-tests_public/test_create_memory_contract.py
-tests_public/test_development_closeout.py
-tests_public/test_explicit_memory_update.py
-tests_public/test_explicit_update_contract.py
-tests_public/test_g1_memory_contract.py
-tests_public/test_g2_source_contract.py
-tests_public/test_hermes_native_provision.py
-tests_public/test_hermes_source_metadata.py
-tests_public/test_incremental_commit.py
-tests_public/test_incremental_configured_runtime.py
-tests_public/test_incremental_dates.py
-tests_public/test_incremental_execution.py
-tests_public/test_incremental_execution_recovery.py
-tests_public/test_incremental_native.py
-tests_public/test_incremental_partial.py
-tests_public/test_incremental_partial_boundaries.py
-tests_public/test_incremental_partial_recovery.py
-tests_public/test_incremental_preview.py
-tests_public/test_incremental_protocol.py
-tests_public/test_incremental_recovery.py
-tests_public/test_incremental_remember.py
-tests_public/test_incremental_remember_recovery.py
-tests_public/test_incremental_scope_recovery.py
-tests_public/test_incremental_scopes.py
-tests_public/test_inspection_read_budget.py
-tests_public/test_mcp_retrieval_fallback.py
-tests_public/test_migration_backup.py
-tests_public/test_migration_runtime.py
-tests_public/test_native_read_stability.py
-tests_public/test_planner_provenance_contract.py
-tests_public/test_platform_contracts.py
-tests_public/test_processed_state_contract.py
-tests_public/test_processing_entrypoints.py
-tests_public/test_processing_route.py
-tests_public/test_processing_route_recovery.py
-tests_public/test_provider_compatibility.py
-tests_public/test_public_query_integrity.py
-tests_public/test_query_benchmark.py
-tests_public/test_query_clock.py
-tests_public/test_query_progress.py
-tests_public/test_query_scan_reuse.py
-tests_public/test_release_assets.py
-tests_public/test_remember_route.py
-tests_public/test_remember_route_recovery.py
-tests_public/test_revision_target_integrity.py
-tests_public/test_runtime_retention.py
-tests_public/test_runtime_retention_observation.py
-tests_public/test_runtime_retention_recovery.py
-tests_public/test_source_followup_contract.py
-tests_public/test_vault_binding_contract.py
-tests_public/verify_distribution.py
+src/memleaf/llm/thinking.py

memleaf-0.2.68/docs/installed-artifact-verification.md

@@ -1,131 +0,0 @@
-# Installed artifact and native-platform verification (G5c)
-
-This is a deterministic CI gate, not a new runtime subsystem or live-model
-acceptance. It follows FS183, FS185-194 and the installation/process portions
-of E10/E17/E19. Existing extraction defaults, prompts, budgets, public interfaces
-and package version are unchanged. Running these checks does not install a real
-Hermes host, read a production Vault, create a release or authorize migration.
-
-## Build once, test the same distribution bytes
-
-The build job runs the complete public source suite and records the discovered
-case inventory. It builds one wheel and one sdist, verifies that **all** packaged
-Memleaf files match (including the Provider resources), and creates a manifest
-binding artifact sizes/hashes, test assets, inventory and the current commit.
-Verification inputs (manifest and test-only dependencies) use a separate
-artifact; `memleaf-distributions` continues to contain only the release wheel
-and sdist, so downstream PyPI publishing cannot ingest test data. The build job
-exposes the manifest hash separately as a job output. A verification
-job must match that hash and commit before installing the downloaded artifacts.
-This catches accidental cross-run/mixed artifacts; it is not a signed supply-chain
-attestation against replacement of the workflow and its own evidence together.
-
-`verify-artifacts` covers five cells:
-
-| Native runner | Python |
-|---|---|
-| Ubuntu | 3.11, 3.12, 3.13 |
-| Windows | 3.12 |
-| macOS | 3.12 |
-
-This is not a full OS/Python/architecture Cartesian matrix. Every cell downloads
-the same build artifact. The sdist is rebuilt locally on that runner, and the
-resulting Memleaf payload must equal the original wheel before it is tested.
-Archive timestamps and packaging metadata may differ; implementation/resource
-bytes must not. Neither cell rebuilds from a different checkout and calls that
-the originally tested binary.
-
-Each cell creates **two fresh virtual environments**, one for the original wheel
-and one for the sdist-built wheel. Only public test assets and examples are copied
-to a separate temporary workspace. The extracted source directory is removed
-before either suite runs. The test Python uses isolated mode; inherited
-`PYTHONPATH`, Python home settings and product/model configuration variables are
-removed. Child crash/restart tests use that environment's Python too.
-
-Before and after discovery/execution the reporter verifies that `memleaf` and
-its loaded submodules come from that environment's site-packages. It compares
-installed test IDs and count to the source-job inventory, fails on empty/missing
-cases, errors, failures, skips or expected failures, and verifies installed
-package bytes after execution. It does not report success just because a help
-command returned zero, or because a source-tree import masked a broken install.
-
-## Reuse existing contracts; add native-process evidence
-
-The existing complete public suite remains the main acceptance surface. Added
-focused checks exercise Unicode/spaces in Vault paths, exact UTF-8 and LF/CRLF
-file handling, real process lock contention, OS process-exit lock release,
-case-insensitive identity collisions and missing timezone data. These checks do
-not patch `os.name` to pretend Linux is Windows.
-
-The installed smoke check starts the actual generated `memleaf-mcp` executable
-through byte pipes twice and uses the packaged Hermes MCP client for a
-`scope_catalog -> search -> read` exchange. It overrides the child environment to
-`PYTHONUTF8=0` and `PYTHONIOENCODING=cp1252`; the MCP transport must still exchange
-UTF-8, including Chinese and emoji. Both actual console scripts also run directly.
-
-Hermes' two base-interface classes are stubbed solely to load the bundled client.
-Transport, executable, process boundary and Vault operations are real; a running
-Hermes installation, Provider registration, installed-host lifecycle and user
-configuration are **not** tested by this stub. The report leaves installed
-Hermes/live semantic acceptance `not_run` and `switch_authorized=false`.
-
-The suite's old POSIX-only exclusion for one symlink test is removed. Hosted
-runners must support the filesystem primitives under test. Capability failures or
-other skips make the gate fail rather than becoming a green reduced suite. A
-separate native setup issue can then be diagnosed explicitly; assertions must
-not be disabled merely to obtain a green matrix.
-
-## Encoding and timezone fixtures
-
-The general test runner explicitly enables UTF-8 for test-file I/O on all
-platforms; historical tests contain Unicode fixtures. That harness setting is
-not evidence that a user terminal has UTF-8 enabled. The separate stdio tests
-intentionally disable it, so protocol correctness does not depend on the harness.
-
-Windows does not necessarily have an IANA zoneinfo database. The build job obtains
-`tzdata` as a **test-only wheel**, hashes it in the same manifest, and verification
-jobs install only that bound wheel offline into the disposable test environments.
-Memleaf runtime dependencies and its behavior when timezone data is unavailable
-remain unchanged. No dependency is silently installed into a user's environment.
-The negative missing-zone test still checks explicit failure and UTC fallback.
-Build tools and runners can evolve; reports retain Python/OS/architecture and
-artifact hashes, not a claim of hermetic or bit-reproducible build infrastructure.
-
-## Reports, failure and release dependency
-
-The source report and each cell's stage JSON/logs are uploaded separately. Reports
-include actual test count and skips, test-inventory hash, package import root,
-Python/OS/architecture, durations and the candidate manifest. An interrupted or
-failed command fails the job; available earlier-stage reports remain available.
-A wheel pass followed by an sdist failure is not a platform pass. `fail-fast:false`
-allows other cells to finish without hiding their results; it does not relax the
-aggregate dependency.
-
-The existing release job now requires **build and all installed-artifact cells**.
-Existing release conditions and explicit `release: v...` authorization remain.
-Ordinary development commits do not create tags, GitHub Releases or PyPI uploads.
-This change only adds a deterministic prerequisite; it cannot replace live Flash,
-held-out multi-turn review, real host testing, backup/Forget checks or operator
-switch authorization. Until a commit's matrix has actually run, its native
-platform results are `not_run`, not inferred from a written workflow.
-
-## Local reproduction
-
-From a clean candidate source directory, with its declared build backend available:
-
-```sh
-python -I -X utf8 tests_public/run_contracts.py --tests tests_public --source-root src --report source-results.json
-python -m build --wheel --sdist
-python -m pip download --only-binary=:all: --no-deps --dest dist/test-dependencies tzdata
-python tests_public/verify_distribution.py manifest --dist dist --source-report source-results.json --commit <candidate-sha>
-python tests_public/verify_distribution.py verify --dist dist --output <new-output-directory> --commit <candidate-sha> --manifest-sha256 <printed-manifest-sha256>
-```
-
-`build`/setuptools are developer tools. The verifier itself uses the standard
-library and the explicitly installed backend for the sdist build. It never
-implicitly fetches a model or a package at runtime: artifact installations use
-`--no-index --no-deps`. On a machine with system IANA data, a local manifest may
-omit the test dependency; record that difference rather than claiming the local
-run used CI's identical dependency set. Existing output is refused. Reports and
-logs here contain synthetic test data only; real-model trace packages follow the
-separate private acceptance contract and must not be uploaded by this job.