Validation record

Local development builds. Results are dated per section; older artifact hashes apply only to the builds recorded with them. Command examples use the current project spelling; historical artifact hashes do not describe the newly named binaries. These results describe checks actually run; CI configuration is not evidence of a successful remote CI run or an independent security audit.

SaaS accounts and configurable registration (2026-10-14)

Release 20261014-83aca4d86199 is deployed on ldny. Linux binary SHA-256: 83aca4d86199718587da2fe812471bffb6ea7aefd499c52ed53e6566a7dd4c73. Account UI deployment: 908a7085.memories-ap4.pages.dev.

• cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, and cargo test --workspace --locked passed on Windows. Existing optional environment-dependent tests retain their declared ignored status.
• cargo build --workspace --release --locked passed on Windows. The Linux memories-center release build passed with the locked dependency graph and was tested in the production-compatible Ubuntu container described below.
• Center tests: 79 passed, including seven account/configuration tests covering username registration, canonical identities, email verification/expiry/reuse, SMTP transport failure, actual delivery to a loopback SMTP fixture, password hashing, bounded auth work/requests, cross-account read/write denial, admin changes/deletion, logout, restart persistence and fail-closed member writes.
• Web client and API proxy Node tests: 13 passed. Documentation generation verified local links and anchors in 32 HTML pages.
• Real Chromium registered/logged in against an isolated Center and created a memory. Email form transitions were checked with mocked API responses; those browser checks did not send mail. Backend email delivery was separately checked through the local SMTP fixture, not an external provider.
• The exact production image passed an isolated ldny container canary with two accounts, distinct vaults, cross-account denial, logout, restart persistence, and login while registration was closed. The canary container and its synthetic data were removed. Production data was not used for that test.
• Production restart preserved the existing owner's vault identity and member token through the public domain. The existing PostgreSQL container and cloudflared service remained running. Embedded /app/ assets and public Pages assets match. Public desktop/mobile pages have no browser console errors and no horizontal overflow at 390px.
• Production selects email mode in /etc/memories-center/auth.toml. SMTP was configured on 2026-10-14 using Tencent enterprise mail with certificate-verified implicit TLS on port 465. Provider authentication passed, the service restarted successfully, and the public configuration reports registration enabled. A public registration request returned 200 with verification_required: true after submitting a verification email to the provider. Inbox receipt and the user's final code/password submission remain unverified. Passwords are kept only in protected configuration outside the repository.
• Protected consistent backup: /var/backups/memories-center/20261014-before-accounts-83aca4d86199/state-and-config.tar.gz. Evidence, source patch and build receipt: dist/saas-accounts-20261014/. The patch applies to the recorded clean base; Git normalizes text line endings.

Hosted SaaS on ldny (2026-10-14, initial deployment)

memories.ivjn.us now serves the hosted Center API through a Cloudflare Worker and the existing ldny Tunnel. The static website, Web client and independent documentation remain on Pages. ldny runs the Linux release in an Ubuntu 24.04 Podman container, with persistent encrypted data outside the image and systemd startup/restart management.

• Public /health returns ok; /v1/public-key identifies memories-saas. Anonymous /v1/session returns 401, and a scoped member/grant returns the authorized session. API responses use Cache-Control: no-store.
• Synthetic content survived a service restart. Real Chromium created, edited and reopened a memory through https://memories.ivjn.us, then deleted it. The final container release passed two consecutive systemd restarts with a fresh persisted test item. A 1 MiB binary file uploaded/downloaded through the public API matched SHA-256; read-only grants rejected writes with 403.
• Desktop and 390px mobile browser checks had no horizontal overflow or console errors. Tokens/content were absent from browser storage. QA content was cleared and temporary grants revoked. An existing owner token still worked after the final upgrade; a protected pre-upgrade state/configuration backup was retained.
• All 10 Node tests for the Web API and edge proxy passed. Linux release build and local Linux authentication/persistence/embedded-asset smoke checks passed.

See the repository's deploy/README.md for service layout and rollback. Secrets were generated on the server and kept out of the repository. These checks do not establish independent security certification or public self-service account registration. Local evidence is in dist/saas-ldny-20261014/.

Memories Web (2026-10-14, initial frontend deployment)

Added the static Center client at /app/ and bundled the same assets into memories-center. This is a hosted Center client, not an offline browser vault. This initial frontend deployment preceded the SaaS rollout recorded above.

• The full Rust sequence passed: format check, workspace/all-target Clippy with warnings denied, locked workspace tests, and locked workspace release build. The Center suite includes explicit-origin validation and CORS scope/auth tests.
• node --test scripts/tests/web-client.test.mjs: 6 passed, covering token origin binding, redirect/cookie/cache restrictions, partial updates, cancellation and stale responses, failed connection races, generic errors and binary encoding.
• Real Chromium connected the static site on port 8097 to a disposable hosted Center on port 9297. Memory create/edit/reopen, card create/delete, file upload and download passed. A 10,240-byte binary download matched the source SHA-256. Reader grants disabled mutations; a write-only grant created a memory that was independently read using the owner grant, with the deleted card absent.
• Desktop and 390px mobile workspace layouts were inspected. Explicit disconnect cleared visible content and the token field; the five-minute idle lock was also observed. Neither localStorage nor sessionStorage contained tokens or content.
• The release Center served all seven bundled assets byte-for-byte matching the website sources. Its /app/ page loaded with no browser console errors or warnings, and the CSP/security headers were checked.

Only synthetic vault data and disposable grants were used. These checks do not claim a connection to a production vault, an independent security audit, or native client feature parity. Evidence is retained locally under dist/site-update-7647166/output/playwright/ and dist/web-client-qa/.

Website client refresh (2026-10-14)

Website follow-up: download cards now share grid rows for hashes, primary buttons and metadata links. Standalone documentation at /docs/ contains 29 generated pages with navigation, heading links and a mobile collapsible menu. python scripts/build-website-docs.py verifies local links and fragment targets across all 30 HTML pages. node --check passed for both website scripts. Browser checks covered the home page, documentation hub, English and Chinese guides and configuration at 390px, 900px and 1440px, without horizontal page overflow or console errors. Download buttons, hashes and BUILD-INFO links have matching vertical positions across the four desktop cards.

Source base: 7647166a6d97e59e9a466fec5ead287892b428af (main, synchronized with origin/main). Windows and Linux packages use this committed source. Android also includes the local R8 constructor-retention fix described below; its BUILD-INFO.json records source_dirty: true and the published source patch.

The public bases are https://r2.ivjn.us/memories/7647166/windows/, https://r2.ivjn.us/memories/7647166/linux/, and https://r2.ivjn.us/memories/7647166/android-cc5ac4b5/. All three packages and their published metadata were downloaded again and matched local SHA-256 hashes. The Android SOURCE.patch SHA-256 is cc5ac4b57ced3bc87738d51da5ded84822627b5f05f8db024d323bde98dda4c2; git apply --check passed against the clean base checkout.

Validation performed:

• Rust 1.98.0 on Windows: cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, cargo test --workspace --locked, and cargo build --workspace --release --locked all passed. Configured ignored tests remain ignored; dependency future-compatibility warnings remain.
• Windows package: 47 manifest files and archive entries verified; extracted CLI --version returned memories 0.1.7, and relay --help passed.
• Linux package: built with bash scripts/package-linux.sh in a clean WSL GNU checkout (glibc 2.39, OpenSSL 3). All 45 manifest files, archive entries and executable permissions verified. Extracted CLI --version and file exec --help passed; ldd resolved all dependencies.
• Flutter 3.44.2 / Dart 3.12.2: flutter pub get, dart format --output=none --set-exit-if-changed lib test integration_test, flutter analyze, and flutter test passed (126 tests).
• Rebuilt ARM64/x86_64 Rust FFI libraries and ran flutter test integration_test/native_smoke_test.dart -d emulator-5680 successfully on Android API 35 x86_64. Updated the obsolete eight-character ID assertion to match the core's even-length 6-16 hex character contract. Rebuilt the ordinary debug APK afterward and verified its native libraries.
• Built the release APK with flutter build apk --release --target-platform android-arm64,android-x64 --build-number 8, aligned it, and signed it using the external configuration documented in AGENTS.md. apksigner verify passed with the existing release certificate SHA-256 d637a37d5dd77aa5753722eccf53ab1b84baed2189e603cef9c34dbf354948f8. Source, merged, stripped and packaged FFI libraries were checked for both ABIs.
• Actual signed-release testing found an R8 startup crash: Room reflectively constructs androidx.work.impl.WorkDatabase_Impl, but its public no-argument constructor was removed. Added a narrowly scoped keep rule, rebuilt, and verified two cold launches and entry into Standalone mode without an AndroidRuntime fatal exception. The failed candidate was withdrawn before website deployment; its public APK URL returned HTTP 404.
• Website JavaScript syntax and local HTML resources, IDs and fragment targets passed checks. Local browser checks at 1440px and 390px passed bilingual switching without horizontal overflow or console errors.

Cloudflare Pages production deployment completed at https://09253fe4.memories-ap4.pages.dev for project memories, branch main, with dirty-source metadata. https://memories.ivjn.us/ returned HTTP 200 and matched the local website/index.html byte for byte. All 12 download/metadata links returned HTTP 200, including the retained macOS links. CSP, nosniff, frame denial, referrer and permissions-policy headers were present. Production browser checks passed at 1440px and 390px with English/Chinese switching, no horizontal overflow and zero console errors or warnings. Screenshots are under dist/site-update-7647166/output/playwright/live-*.png.

Local evidence and helpers are under dist/site-update-7647166/; the Windows package is under dist/v0.1.7/. Signing secrets stayed outside the checkout. macOS remains on the existing v0.1.3 download: the macOS host was offline and GitHub Actions was blocked by the account billing/spending limit. No new macOS or iOS build, physical ARM64 execution, store publication or independent security audit is claimed. Linux validation above supersedes the older baseline's Linux limitation for this package.

Unattended native CI wiring (2026-10-01; scheduled, not executed)

The Rust OS matrix in .github/workflows/ci.yml now schedules explicit native checks after ordinary workspace tests:

• Windows: cargo test -p memories --lib native_dpapi --locked runs the existing current-user DPAPI roundtrip and changed-binding denial tests. They use only synthetic in-memory buffers, freed and zeroized by the native buffer guard; the placeholder custody path is never accessed.
• macOS: cargo test -p memories --lib unattended_backend::macos::tests::native_roundtrip_when_keychain_is_unlocked --locked -- --exact --ignored runs only the ignored native Keychain roundtrip, not other ignored tests. It creates a synthetic, nonsynchronizing entry with a unique temporary-directory binding, then deletes that exact entry before checking the read result or asserting equality. Provision, read and cleanup errors fail the test; a failed create never triggers deletion of a pre-existing entry.

The macOS runner must provide an available, unlocked user keychain permitting no-UI create/read/delete. No keychain unlock, authentication UI, ACL weakening, global keychain changes or password injection is added. Missing or locked keychains fail rather than silently skipping or falling back. If native deletion fails, the test fails and its synthetic entry may remain on the disposable runner. Earlier formatting/lint/test failures can prevent these steps from being reached.

These steps are configured for future push/pull-request CI runs, not executed native evidence. No workflow was dispatched and neither Windows nor macOS native tests were run locally: this implementation environment is Linux with no configured native hosts. Actual native execution and locked/approval-needed no-UI validation remain release gates; CI wiring alone does not complete them.

Linux build and packaging scripts (2026-09-18)

Validated the new Linux shell scripts in Ubuntu on WSL2 from a Windows checkout. bash -n passed for both scripts. Disposable committed fixture repositories and mock build tools exercised release/debug selection, explicit native target selection despite a conflicting CARGO_BUILD_TARGET, paths with spaces, custom Cargo target directories, x86_64/aarch64 archive layout, executable permissions, tracked docs/licenses, source commit metadata and all file/archive checksums. Wrong OS, unsupported targets, invalid arguments, missing OpenSSL, failed builds, dirty checkouts and existing package directories were rejected as expected; existing archives remained unchanged.

The WSL environment has no Rust/C build toolchain, so this validates script behavior with fixture artifacts, not Linux compilation or native runtime. The updated manual desktop workflow includes Linux dependency installation, ShellCheck, Rust checks, packaging, checksum verification and extracted CLI/relay smoke commands; that remote workflow has not been run for this change. Native ARM64 and distribution/glibc/OpenSSL compatibility remain unverified.

Windows v0.1.3 retrieval, embedded models and six-character IDs (2026-09-18)

The v0.1.3 tag and release BUILD-INFO.json identify the source and packaged files. The inference engine is part of the application; model weights are installed separately as verified data files, not run by another application.

• Workspace regression: 158 passed, zero failures, 17 intentionally ignored helper/tool/model-dependent cases. The final six-test retrieval suite also passed separately, including a new in-flight public-to-private document change regression added after the workspace run started.
• Native EmbeddingGemma ran in-process with actual pinned Q4 model files. A Chinese question ranked the relevant English dog document above unrelated finance text, with 768-dimensional finite, normalized vectors. A second real CLI/daemon test built the vector index, retrieved the semantic match and confirmed lock rejection/cache clearing. Both opt-in tests passed after explicitly disabling ONNX telemetry before session creation.
• The final optimized Windows release CLI was also exercised directly through real daemon IPC: six-character IDs, two indexed documents, the cross-language semantic match and lock denial passed. Its report is target/rag-release-smoke.json; no external embedding application was used.
• Model installation through the actual release CLI passed against a disposable loopback mirror: an injected HTTP 429 and interrupted model response recovered through retries/ranges (59 requests, 53 ranges), and all seven model files matched their SHA-256 pins. Repeating installation with the mirror stopped reused verified files offline. No encrypted store was initialized by install.
• HTTP fixtures verify Gemini/compatible payloads, requested dimensions, embedding order/count/dimension checks, learned reranking, citation rejection, transient retries, non-retried authentication errors, cancellation and actual HTTPS proxy CONNECT. Failed bodies and direct API-key echoes are suppressed.
• Search/RAG regressions cover Chinese terms, any/all/phrase modes, Unicode chunk offsets, vector-cache reuse/invalidation, hidden credentials/private/deleted content, lock and grant revocation, cross-vault denial, device-only remote disclosure rejection, and changed documents during model work. CLI and MCP ingestion/retrieval work without a model for BM25 mode.
• Six-character IDs, six/eight-character collision extension, old eight-character input compatibility and typed reference projections pass alongside the existing authorization/storage/FFI regressions. Canonical stored IDs and security fingerprints are unchanged.
• Formatting, workspace/all-target Clippy with -D warnings, optimized builds and a core build without the optional native embedding feature pass. Existing dependency future-compatibility and native linker informational warnings remain.
• Live customer Gemini/generation/rerank services were not called; protocol validation uses synthetic HTTP fixtures. macOS/Linux runtime and mobile native builds were not exercised here. The mobile FFI exposes lexical retrieval but rejects model-backed operations. No Flutter UI was changed.

Model revision: 5090578d9565bb06545b4552f76e6bc2c93e4a66 from onnx-community/embeddinggemma-300m-ONNX. Logs are target/rag-*.log and the download/mirror records under target/. Only synthetic stores, documents and credentials were used.

Windows v0.1.2 desktop status and configuration (2026-09-18)

The v0.1.2 tag identifies this source. Release BUILD-INFO.json binds the exact commit and every packaged file; SHA256SUMS also covers the standalone example configuration. The Windows archive includes the tray executable, embedded WebUI, all tracked documentation, the TOML example and bundled-font licenses.

• cargo test --workspace --locked -- --test-threads=2: 144 passed, zero failures, 14 intentionally ignored subprocess helpers/external-tool cases. A strengthened configuration-forwarding/live-WebUI regression also passed separately against the final source (two desktop integration tests).
• Formatting, workspace/all-target Clippy with -D warnings, and optimized workspace builds passed on Rust 1.98.1 MSVC. Existing dependency future-compatibility and FFI linker informational warnings remain.
• Regressions cover capability/Host/Origin/fetch-site rejection, no mutation or generic IPC routes, token rotation, shutdown with partial HTTP connections, passive idle expiry, hidden locked details and MCP denial. Real daemon/WebUI integration covers setup, unlocked counts, lock and disconnect.
• Configuration tests cover CLI/environment/file precedence, relative storage, no-store inspection, explicit config forwarding to probes, saved language in the selected home, relay defaults, malformed values, redacted errors and preservation of existing configuration files.
• Actual Windows release CLI/tray processes started with a disposable TOML file and synthetic store. The browser verified locked/unlocked states and three synthetic libraries, all five languages, and desktop/390-pixel layouts with no horizontal overflow or browser errors. The tray process stayed responsive without startup errors. Native menu clicks were not verified because the automation surface did not expose a taskbar/tray window.
• cargo package --list includes the embedded assets/fonts, configuration template and launcher sources. macOS shell/embedded-Python packaging syntax checks passed. macOS compilation, menu-bar runtime, signing/notarization and Linux runtime checks were not available on this Windows host.
• No mobile assets or Flutter code changed; Flutter/native-device runs and the opt-in external cryptographic-tool cases were not repeated for this release.

Logs are target/desktop-config-*.log and target/config-tests.log. The manual Build desktop packages workflow provides Windows/macOS package jobs; a workflow definition does not establish a successful macOS build.

Windows v0.1.1 documentation and password ID aliases (2026-09-18)

The v0.1.1 tag identifies the source. This Windows-only prerelease includes every tracked docs/ file with its directory structure intact; its BUILD-INFO.json records the source commit and SHA-256 of each packaged file, and SHA256SUMS covers the archive and build manifest.

• cargo test -p memories --locked --test crypto_jobs --test localization: seven passed, zero failures; three external-tool tests intentionally ignored. Regression coverage confirms --password_id, --password and --password-id produce identical plans/approval digests; a changed credential ID changes the approval. Five-language help advertises the aliases.
• cargo fmt --all --check, workspace/all-target Clippy with -D warnings, and cargo build --workspace --release --locked passed on Rust 1.98.1 MSVC. Existing dependency future-compatibility and FFI linker notices remain.
• Release CLI/relay version and crypto help smoke checks passed.
• The full workspace, external-tool and Flutter results below apply to v0.1.0; those broader suites were not repeated for this CLI alias/documentation update. No mobile artifact was rebuilt; the Flutter application version is unchanged.
• The repeatable packaging command is pwsh -File scripts/package-windows.ps1. Logs for this run are under target/release-0.1.1-*.log.

Windows v0.1.0 prerelease (2026-09-18)

Built locally on Windows x86_64 with Rust 1.98.1 MSVC and Flutter 3.44.2. The v0.1.0 tag identifies the source; release BUILD-INFO.json records its full commit and SHA256SUMS covers the downloadable assets.

• cargo test --workspace --locked -- --test-threads=2: 131 passed, zero failures, 14 intentionally ignored tests. The desktop was active and unlocked; both previously screen-lock-blocked IPC tests passed without exclusions.
• The three opt-in crypto interoperability tests passed separately with synthetic identities: S/MIME, OpenPGP and Android APK/AAB-format signing.
• Rust formatting, workspace/all-target Clippy with -D warnings, and cargo build --workspace --release --locked passed. Existing dependency future-compatibility notices remain.
• Flutter analysis, Dart formatting and all 36 Flutter tests passed.
• Release CLI version/crypto help, relay help, and a real release DLL smoke test (initialize, lock, unlock, lock-all, close) passed with a disposable database.
• GitHub Actions could not start because GitHub reported an account payment or spending-limit restriction. These are local results, not remote CI results.
• Assets are unsigned Windows development binaries. Android NDK setup/download did not finish; Android/iOS artifacts and native device tests were not produced in this run. Linux/macOS builds and production release acceptance remain open.

Logs are under target/release-20260918-*.log.

Mail cryptography and application signing (2026-09-17)

• Three opt-in interoperability tests pass with generated identities only: S/MIME signing/verification and PKCS#12 encryption/decryption; OpenPGP detached signing/verification and encryption/decryption; Android APK alignment/signing/ verification and AAB-format JAR signing/verification. The APK fixture has a real binary Android manifest; the AAB test is a synthetic JAR container, not a deployable App Bundle. No real account, identity or application was used.
• Host tools: Git for Windows OpenSSL 3.5.6, MSYS GnuPG 2.4.9, Adoptium JDK 17, Android Build Tools 35.0.0 and the Android 36 platform JAR. GPG tests use --msys-gpg and disposable keyrings. Run the opt-in tests with the MEMORIES_TEST_* tool paths named in crates/cli/tests/crypto_jobs.rs and cargo test -p memories --locked --test crypto_jobs -- --ignored --test-threads=1.
• Core regressions cover local elevation, MCP denial, altered approvals, changed inputs/tools, existing outputs, secret-free audit/results, temporary credential cleanup, failed tool execution and tools that succeed without producing output. Five-language CLI help and non-macOS iOS rejection are also tested.
• Excluding the two screen-lock-dependent IPC cases below, the workspace run passes 129 tests, with zero failures and 14 intentionally ignored tests (subprocess helpers and the three separately executed tool tests). The command is cargo test --workspace --locked -- --test-threads=2 --skip actual_daemon_enforces_unlock_sudo_and_suppresses_child_secrets --skip catch_cli_stores_secrets_without_disclosure_and_requires_sudo.
• cargo build --workspace --locked, workspace/all-target Clippy with -D warnings, Rust formatting, diff whitespace and the updated skill's quick_validate.py check pass.
• The full workspace run reached two existing live daemon/IPC failures while the Windows session was disconnected/locked (query user reported Disc, with LogonUI in that session). The daemon's screen-lock hook revoked the synthetic sessions, producing LOCKED or removed remote-session errors. Repeating those tests serially showed the same lock behavior. They require an active unlocked desktop; the lock protection was not disabled for testing.
• iOS signing is implemented but not runtime-validated on macOS. No Android device is attached and no NDK is installed here; native mobile libraries, APKs and iOS artifacts were not rebuilt. Mobile FFI continues to reject desktop process jobs. Physical installation, Apple provisioning acceptance, PGP/MIME mail-client integration and store publication are not claimed.

AI client skill injection (2026-09-17)

• Before pushing, the staged skill-only snapshot was exported to an isolated directory and passed cargo test -p memories --locked --bin memories --test skill_injection --test localization: 25 passed, zero failures, four intentionally ignored subprocess helpers. Formatting also passes there.
• Full working-tree validation, including the pre-existing wiki/clipboard changes: cargo test --workspace --locked -- --test-threads=2: 127 passed, zero failures, ten intentionally ignored subprocess helpers invoked by parent scenarios. Existing authorization, MCP, storage, sync, FFI and relay regressions pass alongside the new installation tests.
• Windows: nine new regressions pass (three unit tests and six CLI integration tests). They cover user/project directories, configuration overrides, duplicate targets, shared override paths, dry-run, idempotency, explicit replacement, conflict preflight, invalid inputs, sibling-file preservation and five-language help. Tests use disposable directories and do not start a daemon or initialize a Memories store.
• A separate Windows junction check confirms that --force rejects a linked skill directory before writing other targets and preserves its original file. The Unix symlink regression is included but was not executed on this host.
• cargo build --workspace --locked, cargo fmt --all --check, cargo clippy --workspace --all-targets --locked -- -D warnings, and git diff --check pass. Existing Rust dependency future-compatibility and FFI linker informational warnings remain.
• The skill-creator quick_validate.py check passes. cargo package -p memories --list --allow-dirty --locked confirms that the bundled SKILL.md ships with the CLI package. Installation requires no network access.
• Discovery paths were checked against current Codex, OpenCode and Claude Code documentation. Live client discovery/model behavior, Linux/macOS execution, Claude Desktop/Cowork and cloud skill uploads were not exercised. No personal skill directories or client configurations were changed during validation.

Wiki secret references and clipboard (2026-09-17)

• Windows Rust workspace: 118 passed, zero failures, ten intentionally ignored subprocess helpers invoked by parent scenarios. Workspace build, Rust formatting and diff whitespace checks pass. The updated CLI, IPC and FFI paths were also checked in targeted runs after their final changes.
• Four core feature regressions pass: exact replacement, safe projections, local elevation/MCP isolation, metadata rejection (including escaped text), protected-card copies, binary/NUL rejection, sync, persistence and independent backup recovery. An additional targeted run verifies atomic rollback when replacement expands a document beyond the body-size limit, after the credential has been prepared. Signed historical content intentionally remains unchanged.
• The real CLI/daemon IPC suite passes (three tests and four explicitly invoked subprocess helpers), including replacement, masked reads and authorized copy delivery. The FFI regression passes with the same JSON operations and denies copies after native lock. All fixtures use synthetic secrets and disposable stores; no installed store or user clipboard was used.
• Flutter: 36 tests passed, including five new cases for hidden replacement input, elevation before clipboard writes, discarded late responses after background lock, copy failures, and reference preservation during editing. Clipboard delivery uses a mocked platform channel. Flutter analysis, Dart formatting and workspace/all-target Clippy with -D warnings pass.
• Native Windows clipboard calls compile but were not exercised against the interactive clipboard. Linux/macOS clipboard helpers and mobile OS clipboard delivery were not run. No Android device was attached and no NDK was installed in the configured SDK; Android libraries/APK and iOS artifacts were not rebuilt.
• Logs: target/wiki-secret-tests.log, target/wiki-atomic-tests.log, target/wiki-ipc-tests.log, target/wiki-ffi-tests.log, target/wiki-flutter-tests.log, target/wiki-clippy.log, target/wiki-workspace-tests.log and target/wiki-build.log.

Saved language preferences (2026-09-17)

• CLI tests: 19 passed, eight intentionally ignored subprocess helpers. Persistence tests launch separate CLI processes against disposable homes and verify saving/replacing a preference, startup and help selection, per-home isolation, temporary overrides, clearing the setting, malformed settings, and failed-write cleanup.
• Flutter tests: 31 passed. New regressions verify live system-locale changes update the interface and font fallback without writing a preference. Saved choices remain fixed; resetting to the system default survives restart.
• Flutter analysis, workspace/all-target Clippy with -D warnings, Rust/Dart formatting, and diff whitespace checks pass. Native devices were not exercised.
• Logs: target/i18n/persistence-rust.txt and target/i18n/persistence-flutter.txt.

Five-language client and CLI (2026-09-17)

Host: Windows x86_64, Rust 1.98.1 MSVC, Flutter 3.44.2 / Dart 3.12.2.

• Rust workspace tests: 112 passed, ten intentionally ignored subprocess helpers. CLI localization tests also pass on the final CLI changes.
• Flutter widget/unit tests: 29 passed, including five system languages, English fallback, persisted language selection, unlocked-session preservation, phone-width dialogs, plural counts, and protected preview masking.
• Flutter analysis, Rust/Dart formatting, workspace/all-target Clippy with -D warnings, and diff whitespace checks pass. Existing Rust dependency future-compatibility notices remain.
• CLI help, nested help, locale precedence, and localized non-interactive errors were exercised through the actual binary. JSON fields and error codes remain stable. Widget screenshots were rendered at 390 x 844 with test-loaded fonts.

Local logs are in target/i18n/. The host HTTP proxy was excluded from Flutter's loopback test connections. No Android/iOS device, native file picker, live OAuth provider, or Linux/macOS runtime was exercised for this localization change.

Cloud recovery and revocation follow-up (2026-09-17)

Host: Windows x86_64, Rust 1.98.1 MSVC. Regression fixtures use synthetic data, temporary encrypted databases and loopback HTTP only.

• cargo test --workspace --locked -j 2 --no-fail-fast -- --test-threads=2: 106 passed, ten intentionally ignored subprocess helpers. This includes all 24 cloud synchronization/HTTP integration tests.
• cargo fmt --all --check and workspace/all-target Clippy with -D warnings pass. The existing dependency future-compatibility notices remain.

The regression suite covers damaged download responses followed by healthy retries, rejected objects remaining distinct from successful imports, and a one-time rescan of legacy receipts. It also checks dependency downloads with a full inbox, eviction of unreferenced envelope buffers, and directory cursors remaining on a partially admitted page.

Revocation tests cover both queued data that must never be sent and an upload already in flight: the latter may finish, but the next request is prevented and its stale acknowledgement is rejected. The Google Drive fixture accepts duplicate names and rejects only duplicate file IDs. Its restart test interrupts the worker after the server accepts a file, verifies the ID was already stored locally, then checks that retrying creates exactly one envelope and one descriptor.

The HTTP fixture explicitly puts accepted sockets into blocking mode on Windows; otherwise they can inherit the listener's nonblocking mode and reset connections before request bytes arrive. The memory fixture now hides objects from both listing and direct downloads when simulating incomplete publication.

No live cloud account or Android/iOS native device was used for this follow-up. The platform and release acceptance limits recorded below still apply.

Reliability and mobile cloud follow-up (2026-09-17)

Host: Windows x86_64, Rust 1.98.1 MSVC, Flutter 3.44.2 / Dart 3.12.2. Synthetic secrets and disposable databases were used throughout.

• Rust workspace tests pass, including the real daemon stalled-client/lock regression. Focused tests additionally verify a blocked cloud HTTP request permits locking, concurrent provider runs are rejected, and a late acknowledgement cannot restore an invalidated session.
• Cloud regressions cover normal OneDrive download redirects without forwarding Bearer tokens, redirect loops/unsafe destinations, per-provider enqueue and reconnect, completed queue compaction past the old 256/4096 limits, and temporarily missing objects retrying after backoff. Revoked recipients no longer block preparation for active devices or keep a vault dirty forever. The HTTP fixture now lives until its owner stops it instead of expiring after 30 seconds.
• The Windows FFI test verifies pending background locks on both busy and idle handles and dispatch through the native cloud worker. Native OAuth validation rejects unsafe callbacks and malformed PKCE before network I/O.
• Rust formatting and workspace/all-target Clippy with -D warnings pass. Existing russh/proc-macro-error2 future-compatibility notices remain.
• Flutter analysis and all 16 widget tests pass, including account status and manual locking while a sync request is in flight. Rust access/refresh tokens are never returned to Dart; AppAuth supplies the authorization code/verifier.
• The release storage benchmark runs with 10, 100 and 1000 synthetic records. Results and metric definitions are in performance.md. Audit append no longer derives the same device public key for every prior entry.
• Workflow YAML, embedded signing-configuration Python, Unicode Java-property escaping, Markdown links/fences and diff whitespace are checked locally.

Android SDK/NDK/emulator installation was attempted, but large official archive transfers were too slow to complete during this run. No Android APK/native-device result is claimed for this change. iOS builds require macOS and were not run. The new native CI jobs and manual Android signing workflow have not been run remotely. They are configured checks, not verified build artifacts.

No registered native OAuth client, real cloud consent, signed distribution, physical-device run or independent security review was performed. Google native redirect support must be validated separately for Android and iOS with the chosen registration. See release-checklist.md for acceptance gates. Installed memories binaries and real user vaults were not replaced.

First-release project naming (2026-09-17)

The project, repository, CLI, Rust and Dart packages, FFI symbols and header, Android/iOS identifiers, storage names, environment variables and cryptographic domains now consistently use memories. This first release has no previous-name aliases or migration paths. The repository is https://github.com/mbcc2006/memories.

Host: Windows x86_64, Rust 1.98.1 MSVC, Flutter 3.44.2 / Dart 3.12.2.

• cargo test --workspace --locked -j 2 -- --test-threads=2: 89 passed, ten intentionally ignored subprocess helpers.
• cargo fmt --all --check and workspace/all-target Clippy with -D warnings: passed.
• cargo build --workspace --release --locked -j 2: passed; CLI version and relay help both report the new name.
• Six release CLI/daemon/FFI smoke checks passed with a disposable library: native initialization/write/backup, daemon unlock/read, MEMORIES_HOME selection, CLI read and lock/unlock, native backup restore, and the memories_lock_all export locking active native handles.
• Dart formatting and flutter analyze: passed. Flutter widget tests: 14 passed. The first widget run could not connect to the local test runner because of the host HTTP proxy; rerunning with proxy variables removed from that process and loopback in NO_PROXY passed.

Local evidence is in target/rename-tests.log, target/rename-clippy.log, target/rename-release-build.log, target/rename-e2e.log, target/rename-e2e-report.json, target/rename-flutter-analyze.log, and target/rename-flutter-tests.log. The E2E report binds its result to the CLI hash. Android APK/iOS builds and native device integration tests were not run in this rename. The real-service proxy E2E results in the next section describe their earlier build; this section records the new release's local smoke checks.

SSH/database proxies and release E2E (2026-09-16)

Host: Windows x86_64, Rust 1.98.1 MSVC. The release CLI/daemon was exercised against disposable OpenSSH 8.9p1, PostgreSQL 14.24, MySQL 8.0.46 and Redis 6.0.16 servers in Ubuntu 22.04 WSL. Server packages were extracted into a private temporary directory, with independent data, certificates and synthetic accounts; no system services were installed. The test daemon used a disposable --home. All fixture servers were stopped and their data/private keys removed afterward.

• Workspace regression: 88 passed, ten intentionally ignored subprocess helpers. Command: cargo test --workspace --locked -j 1 -- --test-threads=1.
• Subsequent short-ID fixes passed all nine remote tests and the real daemon IPC scenario. The final shutdown fix passed the four proxy tests, both IPC scenarios, and an additional immediate-stop/lock regression with no shutdown sleep/join in the test client. These focused runs follow the full workspace run.
• Final workspace/all-target Clippy with -D warnings, Rust formatting and diff whitespace checks passed. Existing dependency future-compatibility notices for russh and proc-macro-error2 remain; no lint error was suppressed.
• cargo build --workspace --release --locked -j 2 passed. The rebuilt CLI version/help and relay help commands ran successfully. The installed daemon and user data were not replaced.
• 11 real-service E2E checks passed using scripts/test-proxy-e2e.py against the rebuilt release binary. OpenSSH and SFTP clients, psycopg2, PyMySQL and redis-py connected to daemon-created loopback proxies without upstream secrets.

E2E coverage includes short-ID credential import and secret-read denial; SSH host-key mismatch rejection; stdout, stderr and exit-status forwarding; an SFTP upload/download; untrusted PostgreSQL TLS rejection; PostgreSQL SCRAM, verified TLS, Unicode and transaction rollback; MySQL caching-SHA-256, verified TLS and four-byte Unicode; Redis AUTH over TLS; MCP elevation isolation; explicit stop without interrupting other proxies; and lock closing all listeners plus already established SSH/database connections.

The first E2E run found that proxy stop returned while the accept loop could still forward requests for up to 200 ms. The service now owns and joins the proxy worker before acknowledging stop/lock. The final E2E rerun checks disconnection immediately after the response and passes.

Local evidence: target/proxy-20260916-workspace-tests.log, target/proxy-20260916-remote-tests.log, target/proxy-20260916-shutdown-tests.log, target/proxy-20260916-close-regression.log, target/proxy-20260916-clippy.log, target/proxy-20260916-release-build.log, target/proxy-20260916-e2e.log, and target/proxy-e2e/results/report.json. The report binds the E2E result to the CLI SHA-256 below. The reusable script requires externally provisioned disposable fixtures as described in its module documentation; it does not install servers.

Android/iOS artifacts and native runtime tests were not rebuilt or run in this desktop proxy change. No production SSH/database or live cloud account was used.

Cloud object sync (2026-09-16)

Added a provider-neutral immutable-object runner with durable outbox/inbox receipts. Coverage is in crates/core/src/sync.rs unit tests and crates/core/tests/cloud_sync.rs:

• Exact envelope bytes persist across process reopen; a failed put retries the same object ID without re-encrypting.
• Duplicate put downloads and verifies the existing object before marking the job uploaded.
• A descriptor listed before its envelope stays pending; revealing the envelope and reordering/duplicating the listing still imports once.
• A corrupted download is recorded as corrupt and does not merge vault state.
• Lock and logout increment the sync session so a late CloudSyncAck cannot import; incomplete outbox jobs remain in encrypted state after unlock until cancelled by logout.
• Two paired devices exchange concurrent edits over MemoryTransport.
• Local-only vaults and MCP callers cannot enqueue or inspect work. Backups and restored libraries have empty cloud_sync and no cloud accounts.

Daemon-owned SSH/FTP/TCP sessions with per-instruction propose/approve/exec were added (crates/core/src/remote.rs, crates/core/tests/remote.rs). MySQL, Redis, and PostgreSQL sessions keep state on the live connection and enable TLS by default (hostname verification; optional PEM CA credential). --no-tls is explicit. Live database TLS handshakes were not run. SSH/TLS key generation keeps private keys inside credential storage; tests assert generate/public responses contain no private key PEM. Loopback SSH/Redis proxies inject stored credentials so a local client can connect without the secret; lock sets the proxy stop flag. Live accounts were not used.

Token refresh, OneDrive/Google Drive adapters, daemon CloudSyncRun, and memories cloud sync were added. Coverage is in cloud.rs refresh tests and crates/core/tests/cloud_drive.rs loopback fixtures. Live Microsoft/Google accounts were not authorized. Mobile login/sync UI was not added.

Local check on 2026-09-16 (Windows x86_64, rustc 1.98.1 GNU, MinGW-w64 GCC 16.2.0):

• cargo test -p memories-core --locked -j 1 -- --test-threads=1: 49 passed, two intentionally ignored subprocess helpers.
• cargo clippy -p memories-core --all-targets --locked -- -D warnings: passed.
• cargo fmt --all: passed.

Repository review (2026-09-09)

• Windows Rust workspace: 51 passed, zero failures. Ten intentionally ignored subprocess helpers are launched explicitly by their parent tests. Command: cargo test --workspace --locked -j 1 -- --test-threads=1.
• Initialization tests kill a process after staging and before publication, then successfully recreate/unlock the store. Existing destinations, including a file appearing during initialization, remain intact; the destination OS lock stays held until publication finishes. This does not simulate physical power loss.
• Credential capture rejects duplicate JSON keys, including nested objects and escaped-equivalent names. Tests retain valid array/pointer/string behavior, error redaction, and rejection through actual CLI/daemon IPC.
• A delayed HTTP profile fixture confirms OAuth network latency cannot extend access-token validity. Existing provider exchange and lock/logout cancellation regressions pass. Relay WebSocket tests now include Ping/Pong; control replies use the same ten-second send timeout as queued data. A saturated-socket soak test was not performed.
• Workspace/all-target Clippy with -D warnings, Rust/Dart formatting, diff whitespace, and local Markdown link/fence checks passed. Flutter analysis reported no issues; all 14 widget tests passed.
• The rebuilt Windows FFI passed disposable synthetic-data checks for successful initialization without leftover staging files, stale-ticket rejection after lock, encrypted account persistence across reopen, metadata-only status and local logout. The fixture was removed afterward.
• Local logs: target/review-20260909-rust-tests.log, target/review-20260909-clippy.log, and target/review-20260909-flutter-tests.log. Rust used D:/memories-build-cache/cards with one build job/test thread.
• No live Microsoft/Google authorization, Android/iOS native execution, or Linux/macOS runtime check was performed in this review. Installed binaries were not replaced; remote CI and release artifacts were not validated.

Cloud authorization (2026-09-09)

• Windows Rust workspace: 47 tests passed, including cloud authorization and storage fault regressions. Nine helper tests are excluded from discovery and explicitly launched by their parent scenarios.
• Workspace/all-target Clippy with -D warnings, Rust formatting, and diff whitespace checks passed. The final nonblocking browser-launch adjustment was followed by the CLI cloud tests, Clippy, and a fresh CLI/FFI build.
• Both OAuth providers were exercised with local HTTP fixtures: PKCE, state, account identity, scope checks, missing refresh tokens, response limits, rejected redirects, and generic errors without secret reflection.
• A real loopback socket test rejected an unrelated callback and accepted the matching callback without reflecting its code into the HTTP response.
• Core regressions checked caller/provider binding, replay, lock/logout cancellation, encrypted persistence, audit/MCP isolation, and the absence of cloud tokens from decrypted backup and synchronization payloads.
• A temporary Windows FFI fixture using synthetic tokens passed authorization persistence across close/reopen, cancellation by memories_lock_all, and logout. The fixture was removed afterward.
• No registered client configuration or live cloud account was supplied, so real Microsoft/Google consent and token issuance remain unverified. No cloud files were uploaded. No Android device/emulator was attached; Android/iOS native execution and mobile login UI were not validated in this change.
• Local development binaries were built; installed CLI/daemon binaries were not replaced, and no remote CI or release result is claimed.

Pre-push validation (2026-09-09)

• Rust workspace regression: 30 passed; two IPC child helpers remain explicitly invoked by the parent scenario. Short-ID collision, history, protected-reference and grant roundtrips are included.
• Workspace/all-target Clippy with -D warnings and Rust formatting passed. The short-ID parity check was updated to is_multiple_of; both ID unit tests passed again after that equivalent lint correction.
• Dart formatting, Flutter analysis and all 14 widget tests passed.
• Windows tests used D:/memories-build-cache/cards, one build job and one test thread. Old PDB files causing LNK1201/LNK1207 were preserved with a .pre-push-20260909 suffix before regeneration. The successful workspace log is target/push-20260909-rust-tests.log.
• Release binaries and Android artifacts were not rebuilt during this check; the earlier artifact hashes below do not validate the new short-ID protocol. Remote CI results are tracked separately.

Password length follow-up (2026-09-09)

Local and backup passwords no longer have an application-level minimum or maximum length policy. Empty input is accepted. Confirmation, Argon2id parameters, authentication, sudo scope, and encrypted storage remain in place.

• New core regression passed for lengths 0, 1 and 4096: storage creation, authentication, unlock, backup and recovery; incorrect passwords are rejected.
• Workspace/all-target Clippy with -D warnings and Rust formatting passed.
• Flutter analysis and all 14 widget tests passed, including initialization with empty and one-character passwords while retaining the confirmation step.
• Rebuilt Windows CLI/FFI and restarted the local daemon. A separate temporary fixture against the release FFI passed one-character init/unlock/sudo, an empty backup password, and recovery protected by a one-character password.
• Rebuilt both Android ABIs and the normal-entrypoint APK. Source/merged and stripped/APK native library equality checks passed. Android runtime integration was not rerun for this length-only change; the native test fixture now uses a one-character password for the next device run.

These hashes supersede the earlier artifact records. The build log is target/password-length-android-build.log; detailed ABI hashes are in target/password-length-artifacts.json.

Cards, protected metadata and OTP follow-up

The following feature checks and artifacts supersede the baseline build hashes recorded later in this document. All credentials used during validation were synthetic; no supplied account credentials or mail servers were used.

• Rust workspace regression: 25 passed. The extended CLI IPC scenario and RFC 6238/malformed-input checks also passed after their final test additions. Two helper tests are deliberately ignored by discovery and explicitly executed by the IPC scenario (credential injection and sibling-process sudo).
• Rust formatting and workspace/all-target Clippy with -D warnings: passed. Windows debug checks used D:/memories-build-cache/cards and -j 2.
• Flutter analysis and all 12 widget tests: passed. Coverage includes a phone-size graph, directed backlinks, masked previews, private OTP authorization, expiry, and closing the OTP dialog on background/lock.
• Rebuilt the Windows release workspace. A real release CLI with a temporary encrypted store recorded Python 3.13.1 and its executable directory, marked the vault local-only, and found the observation through card search. The fixture and daemon were removed after the check.
• Rebuilt ARM64/x86_64 Android FFI libraries. The API 35 x86_64 emulator passed the real FFI integration test: cards/links/graph, dotenv key-only search, TOTP generation, credential read denial, audit and lock/unlock. Log: target/cards-android-native-test.log.
• Rebuilt and installed the normal-entrypoint development APK after the integration test. Startup, password initialization, library creation, and opening the new protected-card form succeeded. Further manual account-form submission was interrupted when the emulator disappeared from ADB; that additional manual scenario is not recorded as passed. Startup XML: target/cards-android-startup.xml; build log: target/cards-android-build.log.
• Packaged native libraries were checked per ABI: source equals Gradle merged output, and stripped output equals the APK entry. Evidence and sizes: target/cards-artifacts.json.

Core security tests cover separate encrypted credential storage, atomic failure, secret absence in search/list/graph/MCP/audit and plaintext database bytes, reference-replacement denial, host restriction/header injection, local-only exclusion from pairing/sync/backup, and OTP references after sync/recovery. RFC 6238 coverage includes all six standard timestamps for SHA-1/SHA-256/SHA-512, plus six-digit output and malformed seed/period rejection. HTTP header tests use synthetic values and verify sensitive-header marking; no authenticated request to a production service was made.

Current artifacts (development build, not signed for distribution):

Packaged Rust SHA-256:

Platform limitations at the end of this document still apply. This section records local validation; no remote CI result is claimed here.

Baseline Windows Rust workspace

Host: Windows x86_64, stable Rust 1.98, MSVC toolchain, bundled SQLite.

The ignored test is the child executable used by the IPC test and is explicitly run there under credential injection. It is not a skipped security scenario.

The tests exercise authenticated encryption and transport tampering, encrypted SQLite state, incorrect passwords, checkpoint truncation, chunk ordering, permissions, device approval and revocation, identity reauthorization denial, shared membership, replay, concurrent revisions, policy fork resolution, and independent backup recovery. A real CLI daemon test covers unlock, terminal sudo, credential read denial, executable digest approval, child output suppression, signed audit, MCP scope and locking. A real WebSocket test checks live routing and room cleanup after disconnection.

The Windows named-pipe implementation uses blocking framing. An attempted PIPE_NOWAIT implementation failed the real-daemon regression and was replaced; same-user availability limits are documented in SECURITY.md.

Baseline Windows artifacts (paths relative to the checkout; build outputs are ignored by Git). The CLI also passed --version and --help execution:

Flutter and mobile native libraries

Toolchain: Flutter 3.44.2 / Dart 3.12.2, Android NDK 28.2.13676358, Android SDK platforms 35, 36, and 37.0, Gradle 9.1.0.

Widget tests verify that native startup failure leaves the library locked, backgrounding dismisses content dialogs and clears the authorization state, and idle expiry also dismisses an already-open content dialog. Late asynchronous responses are rejected after a mobile authorization generation changes. The native integration test uses a temporary on-device database rather than a mock backend. It initializes the real Rust service, writes and reads memory, requires elevation to add credentials, rejects credential reads, verifies the audit chain, locks all native handles, and unlocks persisted content without restoring elevation. The fixture directory is removed after the test.

The emulator runs an existing API 35 x86_64 image in read-only mode, with no snapshot saved. Test output is available locally at target/android-native-test.log. The Android build emits a legacy SDK XML-version warning from a plugin toolchain, but this did not prevent compilation or native execution. The app's compile SDK is 37 to meet secure-storage plugin requirements.

The final normal-entrypoint APK was rebuilt after integration testing, installed, and exercised through Android UI automation. Checks passed for startup with the actual secure-storage plugin, password initialization, creating a library and memory, reading that memory, backgrounding while content is open, returning to a locked screen, and unlocking to read persisted content again. This checks the normal app, not just the integration-test entrypoint. UI evidence is stored in target/android-ui-startup.xml, target/android-ui-initialized.xml, target/android-ui-memory-saved.xml, target/android-ui-content-open.xml, target/android-ui-background-locked.xml, and target/android-ui-unlocked-persisted-content.xml. Only synthetic test data was used. The read-only emulator was stopped after verification.

Baseline APK: mobile/build/app/outputs/flutter-apk/app-debug.apk, 177,630,089 bytes. SHA-256: 1d671906316c139eca786e89a5cca2c5d7895a825c0d58f4c32e71e6ff8be382. This is a debug-signed development APK, not a store release.

Both arm64-v8a and x86_64 include the Flutter engine and Rust FFI library. The source JNI libraries match Gradle's merged libraries; Gradle's stripped libraries match the final APK contents. Symbol stripping explains why a raw source-to-APK hash comparison differs. Packaged Rust library SHA-256 values:

The Windows debug build cache was moved to D:/memories-build-cache/20260908/windows-debug to free disk space for emulator validation. Source files and release artifacts remain in the checkout. Android builds used a task-specific target/gradle-home to avoid the host's stale proxy configuration, plus a local repository containing the exact Flutter engine JARs verified against official HTTPS metadata. No engine code or plugin cache source was modified. The caches, wrapper, and jdks directories in this Gradle home are junctions into the host Gradle cache.

Platforms and remaining validation

• Linux and macOS desktop runtime checks have not run on this Windows host. Android cross-compilation does not establish Linux or macOS runtime correctness.
• iOS Xcode compilation, simulator/device execution, signing, Keychain behavior, and the native XCTest require a macOS host and have not run here.
• Android ARM64 physical-device execution has not run; successful cross-compilation alone does not establish hardware behavior or secure-storage guarantees.
• CI defines Windows/Linux/macOS Rust checks and Flutter checks, but no remote CI results are claimed. No release signing or store publication has occurred.
• No independent cryptographic review, penetration test, or large-scale resource test has been performed. See SECURITY.md before using real secrets.

Client defaults and skill generate (2026-10-01)

• memories default set/get/delete round-trip under a disposable --home, reject unknown keys and invalid type values, and remove defaults.json when empty.
• List commands apply vault / type / category defaults when flags are omitted.
• Persona world/thing/event commands resolve omitted vault/asset from persona / vault defaults (VAULT/ASSET, slash form, or asset with vault default).
• memories skill generate / agents generate write AGENTS.md or skill-layout SKILL.md offline without a persona; refuse overwrite without --force.
• cargo test --workspace --locked covers unit and integration tests for these paths.