@dreamforgestudiollc/emet 0.0.0-stage → 0.2.4

package/.env.example

@@ -0,0 +1,136 @@
+# EMET configuration.
+# Copy this file to .env and fill it in. .env is gitignored - never commit it.
+# Real environment variables always take precedence over this file.
+
+# ---- storage (required) ----
+# Atlas: the mongodb+srv:// string from Connect -> Drivers.
+# A local MongoDB (6 or later) also works: MONGODB_URI=mongodb://127.0.0.1:27017/
+# Only semantic_recall needs Atlas (its vector index); everything else runs on either.
+MONGODB_URI=mongodb+srv://USERNAME:PASSWORD@cluster.example.mongodb.net/?retryWrites=true&w=majority
+MONGODB_DB=emet
+
+# ---- provenance ----
+# Every write records the host that made it (its source tag). Register the tags
+# your hosts and bots will use, so a typo is marked, not invented. List every tag
+# you will give the setup interview or pass as `source` - while this is set, a
+# transcript append under a tag not listed here is refused.
+# Unset = any tag is accepted, and the bot guards (bots/ folders, main records)
+# are OFF. See docs/BOTS.md before adding a bot's tag.
+EMET_SOURCE_TAGS=laptop,phone,cli
+# A remote server shared by several hosts: do not set EMET_SOURCE_TAG - a default
+# makes every host look the same; each host passes its own tag on the write.
+# A server used by one host only may set its default tag:
+# EMET_SOURCE_TAG=laptop
+
+# HMAC key for signed digests. Generate once, keep only here / on your host.
+# Never commit a real value. Never store it in Mongo. Unset = entries are saved
+# "unsigned" (everything else works). To make one:
+#   node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
+# EMET_SIGNING_KEY=
+
+# Two doors for a second person into THIS store, each off unless set to 1.
+# Leave both unset on a single-person assistant.
+# EMET Guest Access: one-time codes for read access. Set to 1 only on a
+# household or project EMET meant to be shared.
+# EMET_INVITES=1
+# EMET Member Access: one-time codes for a new person with read and write
+# access (never the owner). Separate from guest access.
+# EMET_MEMBER_ACCESS=1
+
+# The monorail, the server-side check on the order of a session's writes
+# (docs/GUARDRAILS-AND-MONORAILS.md), runs in enforce only and has no setting:
+# EMET_SESSION_GRAPH is no longer read. Every check is stored in <prefix>graph_lab;
+# emet_gaps summarizes it.
+
+# Optional. The time zone session ids are dated in (IANA name). Set it to your
+# own zone, so an evening session carries your day, not UTC's. If unset, the
+# default is America/New_York.
+# EMET_TIMEZONE=America/New_York
+
+# Optional. Minutes after a complete close in which the session still takes its
+# ONE closing exchange (the reply sent after emet_session_close). After that one
+# append, or once the window passes, the session is locked. Default 5; 0 = off;
+# at most 60 (a larger value is capped at 60). A negative or non-numeric value
+# is not used: the server logs a warning and uses 5. The legacy name
+# CASCADE_CLOSE_GRACE_MINUTES is still read as a deprecated fallback; EMET_ wins.
+# EMET_CLOSE_GRACE_MINUTES=5
+
+# Optional. The date from which this record is held to the current rules.
+# Set it and the startup line reports gaps SINCE this date beside the lifetime
+# figure - the lifetime figure never falls once history is in the store; the
+# since-baseline figure is the one that should trend to zero.
+# EMET_GAP_BASELINE=2026-09-07
+
+# Optional. Startup page size in bytes: emet_initialize is served in pages that
+# each fit this budget (default 18000; clamped to 12000-19000). Lower it only for
+# a host that cuts results shorter than the usual 20,000-byte limit.
+# EMET_INIT_PAGE_BYTES=18000
+
+# Optional. read_doc page limit in bytes as the host receives it (default 18000):
+# a page ends before its JSON-escaped text plus 1,500 bytes for the rest of the
+# result would pass it, on a whole character. Offsets are UTF-8 bytes.
+# EMET_READ_DOC_PAGE=18000
+
+# ---- document names (optional; defaults shown) ----
+# The session handoff and the board.
+# EMET_HANDOFF_DOC=HANDOFF.md
+# EMET_STATE_DOC=STATE.md
+# The user's host-and-machine notes.
+# EMET_INSTALL_DOC=bootstrap/INSTALL.md
+# The character document (character and voice). When unset, the usual
+# bootstrap names are tried in order (bootstrap/CHARACTER.md first).
+# EMET_CHARACTER_DOC=bootstrap/CHARACTER.md
+# More record documents, beside the handoff (comma-separated ids): kept as
+# superseded records, never amended. Bot handoffs are listed here, e.g.
+# bots/<tag>/HANDOFF.md.
+# EMET_RECORD_DOCS=
+# More document-to-template mappings for validate_doc, as id=template pairs
+# (comma-separated). Additive only: an entry that would change a built-in
+# mapping is ignored and reported.
+# EMET_TEMPLATE_MAP=
+
+# ---- http transport only (src/http-remote.js) ----
+PORT=8849
+# Local use: keep the server on this machine only.
+HOST=127.0.0.1
+# Deploy-only (container/host behind a proxy): listen on all interfaces.
+# HOST=0.0.0.0
+# When deployed: must exactly match the deployed https URL - it is the OAuth issuer.
+# Leave it unset to run the HTTP server on this machine; it then defaults to
+# http://127.0.0.1:PORT.
+# PUBLIC_URL=https://your-deployment.example.com
+# Typed once per device to authorize it. This is the whole perimeter. Make it strong.
+# While it is unset, the HTTP server refuses every authorization.
+# EMET_OAUTH_PASSPHRASE=
+# The server trusts exactly one proxy hop (Railway's edge). TRUST_PROXY is not read.
+# Client ID Metadata Documents are advertised by default; 0 falls back to
+# Dynamic Client Registration only (a rollback with no redeploy).
+# EMET_CIMD=1
+# One redacted log line per OAuth/MCP request and per error response; 0 silences it.
+# EMET_REQUEST_LOG=1
+
+# ---- optional ----
+# Collection name prefix. Governs layer collections, the counters collection and the
+# OAuth collections. Change only before first use - or set it to cascade_ to adopt an
+# existing upstream CASCADE store in place. See docs/SETUP.md, "Migrating an existing
+# CASCADE deployment".
+# EMET_COLLECTION_PREFIX=emet_
+
+# Atlas Vector Search index used by semantic_recall. Migrating installs set this to
+# cascade_content_auto.
+# EMET_VECTOR_INDEX=emet_content_auto
+
+# Optional supplementary corpus searched by corpus_recall.
+# EMET_CORPUS_COLLECTION=corpus_chunks
+# EMET_CORPUS_INDEX=corpus_content_auto
+
+# Comma-separated names for the optional supplementary corpus searched by
+# corpus_recall. Leave unset unless you have populated a corpus yourself.
+# EMET_CORPORA=
+
+# Diagnostics.
+LOG_LEVEL=info
+LOG_FORMAT=text
+# DEBUG=true
+# EMET_AUDIT_LOG=
+# EMET_CRASH_LOG=

package/CHANGELOG.md

@@ -0,0 +1,296 @@
+# Changelog
+
+All notable changes to EMET are listed here, newest first. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and version numbers follow
+[Semantic Versioning](https://semver.org/). EMET is still 0.x: the stored data shapes may
+change before 1.0.
+
+## 0.2.4 - 2026-10-08
+
+A board fix, a public website, and the first npm package, `@dreamforgestudiollc/emet`. A session that boots with no unhandled drops can edit the board again. No data shapes or settings change; deploy over 0.2.3 as is.
+
+### Added
+
+- A static website in `site/`, for search, and a GitHub Actions workflow that publishes that folder to GitHub Pages on pushes to `main`.
+- `glama.json` at the repo root names `dreamforgestudiollc` as maintainer for the Glama directory listing.
+- The README records the origin in the same words as the site: EMET was built by Dreamforge Studio LLC from a neurodivergent user’s own need for an AI assistant that remembers. The word coined for that is neurendipity: neurodivergent and serendipity.
+- The public-scrub suite reads the Pages workflow's deploy job `if` and requires it to be exactly `github.repository == 'dreamforgestudiollc/EMET' && github.ref == 'refs/heads/main'`. A repository name that only contains that text, such as `dreamforgestudiollc/EMET-private`, does not pass.
+- The same suite requires `site/sitemap.xml`, `site/robots.txt`, `site/.nojekyll`, and every image the site HTML references to be present on the scrub and publish walk. Removing one of those files fails the suite.
+- `server.json` for the Official MCP Registry. Its name is `io.github.dreamforgestudiollc/emet`, the same value as `mcpName` in package.json. The npm package it names is the stdio server at version 0.2.4.
+- The pack test reads the text inside the tarball. On a scrubbed tree, an install-specific name in any packed file fails it. On this private tree that check waits, because the publish scrub has not rewritten those files yet.
+- The site image check fails a root-relative `/EMET/` image URL, a protocol-relative URL, a JSON-LD image in one of those forms, and a path that climbs out of the repository. A second Pages job with no `if` fails the deploy gate.
+
+### Changed
+
+- The README now opens with the search line and a short account of what EMET does, in the same words as the website: an MCP (Model Context Protocol) memory server, persistent shared memory for AI agents, bot teams and chats. The previous opening paragraph, including how to connect a single-session chat, is kept below that.
+- package.json is prepared for a public npm release at version 0.2.4. The package name is now `@dreamforgestudiollc/emet`. It was `emet-mcp-server`. npm refused the unscoped name `emet` at publish as too similar to existing package names, so the package uses the documented scoped fallback with `"publishConfig": { "access": "public" }`. `server.json` names the same package. The command it installs is still `emet`. `@black-knight.dev/emet` is a different server that also installs a command named `emet`. Keywords match the public GitHub topics. `repository`, `homepage` (`https://dreamforgestudiollc.github.io/EMET/`), and `bugs` point at the public project. `bin` and `main` stay `src/index.js`. `engines` stays Node 20 or newer. The `files` list ships the server, the charter, templates, guides, top-level docs, the changelog, the registry manifest, and `.env.example`. It does not ship tests, scripts, `docs/status/`, backups, or `.env`.
+
+### Fixed
+
+- A session that boots with no unhandled drops can edit or restore the board. The empty list was not saved, so the board guard treated it as a list that had failed to load. A list that really failed to load is still refused. Retired drops stay off that list.
+- A module file is opened from `fileURLToPath` and `path.resolve`. On Windows, `new URL(...).pathname` is `/C:/...`, and resolving that against a `C:` working directory produced `C:\C:\...` and the open failed.
+- `.env.example` no longer assigns `TRUST_PROXY`. The server trusts exactly one proxy hop (Railway's edge) and does not read that variable.
+- The example environment that ships is the public one. It listens on `127.0.0.1`, registers the generic tags `laptop,phone,cli`, and leaves `EMET_OAUTH_PASSPHRASE` commented out, so HTTP authorization stays refused until someone sets a passphrase. The pack test fails if the packed example assigns a passphrase, binds `0.0.0.0`, or names this install's source tags.
+
+## 0.2.3 - 2026-10-07
+
+The security fixes from the October audit, recall that ranks by how well an entry matches and keeps ended entries visible, and public wording that matches the code. Read the 0.2.3 checklist in docs/DEPLOY.md before upgrading: every host tag must be listed in `EMET_SOURCE_TAGS`, a `cloud-scheduled-` tag is refused, and an HTTP client whose token has no source tag signs in again once.
+
+### Security
+
+- The client-metadata fetch connects to the public address it already checked. A second DNS answer cannot move that connection onto a private, loopback, link-local, or metadata address. A redirect is still refused.
+- That address check uses the parsed bits of the address. The whole link-local range `fe80::/10` is refused, including `fe90::` and `febf::`. The same check refuses loopback, private, unique-local, unspecified, multicast, IPv4-mapped and IPv4-compatible addresses, NAT64 `64:ff9b::/96`, and carrier-grade NAT. An unreachable pinned address rejects the fetch and does not crash the process.
+- Every HTTP response sends `X-Content-Type-Options: nosniff`, `X-Frame-Options: DENY`, `Referrer-Policy: no-referrer`, and HSTS. The consent page keeps its own content security policy.
+- `save_transcript` no longer reads a file path. The caller passes the exchanges, each field is capped, and the whole request is capped. The server does not read the disk for a transcript.
+- An invite code, an authorization code, and a refresh token can be spent once. A second redeem does not create a second person. Inside a short grace window a repeated refresh returns the replacement already issued; any other reuse revokes that whole sign-in.
+- A board edit or restore runs only when the session has a verified drop list from `emet_session_open`. An append does not open that session. No write may shrink a document below half of its largest size in the last 24 hours. That window is a floor on cuts, not a fading of memory.
+- A refusal does not publish the list of source tags, and a `cloud-scheduled-` prefix is not a registered tag. Over HTTP the source tag is the one bound at approval. Stdio stamps one local subject, and the 20-drop cap is one bucket for the whole local process.
+- Setup, guest invites, and member codes are the owner's. A guest invite is read-only. Opening a session, and a status check that probes the write path, need write access. The probe removes its own document and leaves the collection. An HTTP token with no scopes is not the owner. The consent page shows the scopes it is granting.
+- A governed write that names a session stops when the session record cannot be read. Nothing is written.
+- The client-metadata fetch refuses loopback, private, link-local, and metadata addresses, and it is rate limited. Tool rate limits are per person and client. The HTTP body limit is 256kb, and the server trusts one proxy hop.
+- The consent page sends a content security policy, denies framing, and sends HSTS. Error details are not attached on HTTP, including a rate-limit response. The audit log is redacted the same way as the console.
+- A token issued before source tags were stored may still write when the caller names a tag that is an exact member of `EMET_SOURCE_TAGS`. Refreshing that token is refused (`invalid_grant`): the client signs in again, and the new consent binds a registered tag. Those logins age out on their own. An empty registry has no members, so that fallback does not accept an arbitrary tag.
+- The local stdio client is the owner and can create guest and member codes. Over HTTP those codes still require an owner person. A member code can carry a registered source tag, set by the owner when the code is created and bound when the code is redeemed.
+- A later verified `emet_session_open` clears `drops_unverified` when the drop load succeeds, including when open drops remain. Only a failed drop load sets the flag. An open drop still has to be retired before the board is edited.
+
+### Fixed
+
+- Session start lists the half-finished, dated, open, undecided, and parked rows it can read (`named_items`). A section that is not a table is marked unread, including prose such as "None". Unread is not an empty list: the session still reads the document. An empty list is not a reason to skip the document. Nothing is hidden, and nothing is dropped because it is old.
+- The handoff refusal names `patch_doc` for the board. Restoring the board counts as the board step.
+- Recall orders matches by how many of your words appear, then by importance. Current entries come first in every order, including time order. Pass `order: 'latest'` for time order. A standalone "latest", "newest", or "most recent", together with other words, reorders those matches and does not change which rows match. "latest-budget", "not the latest", and a bare "latest" are ordinary keywords.
+- An entry that has expired or been superseded stays in recall and in layer queries. It is marked with the date it ended and, when a newer entry replaced it, which one. The current entry is listed first, including when you ask for the latest or sort by time. Pass `history: true` when you need the ended entries and the current ones already fill the limit.
+- Revising an entry records the end date and the new entry's id on the old one. The old entry stays readable.
+- Retired documents stay in the document list and in the startup scan, after the current ones, marked with the date they were retired and what replaced them. A retired drop is listed apart from the drops that still need a decision.
+- A recall or a layer query ranks matching rows in the store before it keeps a bounded window (at least 200 rows, or 20 times the page). The rank is the same as the page: current entries first, then how many words match and importance, or time when you asked for the latest. A better match is not dropped for a lower importance or an older time. A blank sort value comes first when the order is ascending and last when it is descending. A word is matched as itself, so `$gt` is that text. Capital and lower case count as the same match, including `École` and `école`. `İ` matches only itself. Full-width letters fold only with their full-width counterparts. `ẞ` and `ß` fold together. The page keeps the store's hit count, so the two do not disagree. The sort may use disk so a layer of large entries can finish.
+
+### Changed
+
+- The public wording now matches the code on who can join (one owner; Guest is read-only and Member is read and write; both stay off until turned on), on the drop-cap buckets, and on working documents (`retire_doc` refuses them; a rename marks the old id retired and the text stays). The charter states the monorail is enforce only, and that a templated write is checked, marked, and kept as the current revision.
+
+### Internal
+
+- Tests now pin the guards a mutation check left unasserted, and the MCP SDK and proxy-addr dependencies are updated.
+- Session close prunes size baselines only for sessions closed or idle more than 7 days, and only those keys. A live session's baseline on a document is not touched.
+- An HTTP caller with no OAuth client id is stored as http:visitor, never in a stdio bucket.
+- The test suite sets the boot-list store timeout short so a missing store does not stall the run.
+- The HTTP visitor check calls the HTTP tool path with no OAuth client id, and the baseline prune check leaves a document with only live or fresh baselines unwritten.
+## 0.2.2 - 2026-10-04
+
+The board is guarded, and the test store is shared.
+
+- A session cannot wipe or overwrite the board. The server sets up a blank board, and a session can only edit it, with a reason. An added item says where it came from. A removed or closed item says why.
+- No change may leave a document under half the size it had when this session first touched it. Overlapping edits and a walk-down across edits are refused. Working documents are edited, not retired.
+- A board edit or restore is refused while a drop listed at that session's boot is still open. Drops are capped at 20 per caller per New York day. A drop with no source is stored as visitor.
+- An owner-listed host can restore an earlier version of the board or a working document, with a reason, when the copy matches its stored hash. A record is not restored. A shipped copy is never restored.
+- Every write records the person and the connected app, stamped by the server from the login, never taken from the caller.
+- A read-only token can initialize and open a session. A missing board is provisioned only for a write-scoped caller, or at setup.
+- The test suites share one in-memory store. No behavior change.
+
+## 0.2.1 - 2026-10-03
+
+Startup comes in pages that fit every host, every startup carries a `load_id`, long documents
+are read in byte-sized pages, and the session-order check now refuses every skipped step, with
+the way to pass in the same reply. After upgrading, each host reconnects once to see the new
+arguments, then reads its startup again before opening a session.
+
+There is no 0.2.0 release: 0.2.1 follows 0.1.0 directly, so this entry lists every change
+since 0.1.0.
+
+### Added
+
+- **Startup in pages.** `emet_initialize` now sends the startup in pages of about 18 KB
+  each, so it fits hosts that cut long tool results short. The rules and instructions that
+  must always be followed come first. Page 1 lists what every page carries, and each page
+  names the exact call for the next one. Every page of one startup comes from the same
+  snapshot, even if new memories are written in between. If the startup changes partway
+  through, the server says so and you start again from page 1. `page: "all"` still returns
+  the whole startup in one result for hosts with no size limit, led by its `load_id`. The page size can be set
+  with `EMET_INIT_PAGE_BYTES` (12,000–19,000 bytes, default 18,000). Hosts may need to
+  reconnect once to see the new `page` and `load_id` arguments. A `page` that isn't a whole
+  number from 1, or `"all"`, is refused with a clear message.
+- **Missing-page check when a session opens.** `emet_session_open` checks that every page
+  of your startup was fetched, named by the `load_id` from your startup pages. An open with
+  a page missing is refused (see Changed).
+- `.env.example` now lists every setting the server reads. New entries include
+  `EMET_MEMBER_ACCESS`, the page-size settings, the document-name overrides,
+  `EMET_RECORD_DOCS`, `EMET_TEMPLATE_MAP`, `EMET_CIMD` and `EMET_REQUEST_LOG`.
+- `CHANGELOG.md` (this file).
+- **`read_doc` version pin.** Pass the `version` (or `sha256`) your first page returned as
+  `expected_version` (or `expected_sha256`) with each later page. If the document changed
+  in between, the read is refused with "document changed - restart from offset 0" and no
+  content, so pages of two versions are never joined. The pin is optional; without it a read
+  works as before. A shipped guide has no version, so pin it by `sha256`.
+
+### Changed
+
+- **The session-order check now refuses every skipped step.** It runs in enforce only: there
+  is no report mode and no off switch, and `EMET_SESSION_GRAPH` is no longer read (remove it
+  from the service's variables). A skipped step is refused before anything is written, and
+  the refusal is recorded in `emet_gaps`. Every refusal says how to pass in the same reply:
+  an open with no `load_id` is told to pass it from the startup pages; a missing startup page
+  is named with the exact `emet_initialize` call; a skipped exchange is named with the
+  `emet_transcript_append` call; a write with no session is told to open one with
+  `emet_session_open` and its `load_id`; a write to a closed session is told the work belongs
+  in the next session; an early handoff names each step and its tool. A session id the caller
+  sent is echoed at most 64 characters, so the instruction always fits. A transcript write
+  with a missing or unregistered `source` is told first to pass one, then which tags are
+  accepted: the first 8 registered tags, then "+N more", and the caller's tag capped at 64
+  characters, so the refusal stays under the cap with any number of registered tags. One exception stays: if
+  the check cannot read the records of the session a write names, the write goes ahead and is
+  recorded as `unknown`.
+  Writes that name no session (for example the scheduled weekly intake) are now refused
+  (gate `no_session`) until they open a session.
+- The startup sends each memory layer's importance band once instead of twice, which saves
+  a little space at the start of every session.
+- **`read_doc` pages are now measured in bytes, as the host receives them.** A long
+  document comes back in pages (was 40,000 characters). A page ends before its text, written
+  as JSON (where every newline, quote and backslash costs an extra byte), plus 1,500 bytes
+  kept for the rest of the result would pass the limit (default 18,000). So a page of
+  quote-heavy, code-like or short-line text holds less document text than a page of prose.
+  The 1,500 bytes is an allowance, not a measurement: a result whose other fields run longer
+  (for example a long list of conformance failures) can still pass 18,000 bytes, and a host
+  that cuts at about 20,000 bytes is not guaranteed the whole result in every case. A page
+  never splits a character. `offset`, `next_offset`, `returned` and `size` in the `page`
+  block are UTF-8 bytes; `returned_escaped` is the page's size as JSON, and `envelope_spare`
+  is the 1,500. Following `next_offset` still gives back the whole document exactly. The
+  result's whole-document `size` stays in characters; `size_unit` says so and `size_bytes`
+  gives the UTF-8 bytes. `EMET_READ_DOC_PAGE` sets the limit (default 18000).
+- **Startup pages say to fetch them all before opening a session.** Page 1 and every page
+  that names a next call now say "Fetch all N pages before emet_session_open; an open with
+  any page not fetched is refused." The line replaces the older "keep calling until a page
+  says it is the last", and binding text stays where it was.
+- **Missing startup pages go through the session-order check.** `emet_session_open` passes
+  a `startup_pages` gate: an open with a page of its startup never fetched is refused,
+  nothing is written, and the reply leads with the exact call for the first missing page and
+  names the missing pages once, as ranges (`2-40`), so it fits the 500-character error cap
+  however many pages are missing. A `load_id` the server has no record of (made up, expired
+  60 minutes after its last page, or from before a restart) is refused too, since its pages
+  cannot be checked: the reply says to call `emet_initialize {}`, fetch every page and open
+  with the `load_id` it returns. After a server restart each host does that once.
+  The record of fetched pages now keeps up to 2,000 loads for 60 minutes after each load's
+  last page (the page cache still keeps 32 payloads for 10 minutes), so many hosts starting at
+  once, or a host that opens a while after reading its startup, still open.
+- **A session open must name its startup.** Pass the `load_id` from your startup pages
+  (`startup_page.load_id`; every page carries it and the last page names it) to
+  `emet_session_open`, so the page check runs on your own startup, never on another host's.
+  It stays optional in the tool schema, but an open without it is refused before anything is
+  written and told to pass it. The server no longer falls back to the latest startup it built.
+- **Every startup carries a load_id, so every host can open a session.** A startup served
+  whole - `page: "all"`, a startup that fits one result, and a store that is not set up yet
+  (or cannot be reached, or is misconfigured) - now leads with `startup_page` (`index`, `of: 1`,
+  `load_id`, `next: null`) and a `page_notice` that says to pass that `load_id` to
+  `emet_session_open`. The load is recorded with every page fetched, so the open passes the
+  page check. The payload after those two fields is unchanged, byte for byte, and its `load_id`
+  is the same one its pages carry. The startup tests' byte-for-byte pins now compare the payload
+  after pinning the two leading fields exactly. On a new store the setup flow opens a session
+  with that `load_id`, appends, records the interview with `emet_setup_complete` (which never
+  needs a session) and closes as usual.
+- When EMET Guest Access and EMET Member Access are both off, the refusal message now
+  names both and the setting that turns each one on.
+- The README explains that Grok Bot teams and single-session Grok chats on the same server
+  share one memory: what the bots save is there for a fresh chat to find once it
+  initializes, and the reverse. A single-session chat uses that memory most reliably when the
+  instruction block from `docs/BOOTSTRAP.md` is in its project instructions, or, where there is
+  no such field, pasted as its first message.
+- The server reports version 0.2.1.
+- The README has a short "Best practices" section: split the work by what each host does
+  best, with a single-session chat for long one-sitting drafting and review and bots for the
+  rest. The one line you send the chat names the document that holds the task.
+- The README says how to connect a single-session chat: add the server's `/mcp` URL as a
+  remote MCP connector on a host that supports its OAuth sign-in, sign in with the passphrase,
+  then put the `docs/BOOTSTRAP.md` block in the project instructions.
+- The README's Best practices section adds eight short entries: fetch every startup page and
+  open with its `load_id`; set `EMET_SOURCE_TAGS` before a second writer; put the instruction
+  block in the project's instructions; standing approval for reads; reconnect after a tool-list
+  change; register a bot in one change; prove the write path with `probe: true`; keep house
+  style in the store.
+- In the public release, the shipped `CHARTER.md` and nine base templates carry no internal
+  ids; the meaning is unchanged. An install whose stored charter is the public 0.1.0 text is
+  reported as differing from the shipped copy until it is rewritten with `write_doc`.
+- **The startup and the docs say to open a session with the startup's `load_id`.** The
+  startup's short instructions read "After every startup page, call emet_session_open with
+  its load_id", and `tools_in_force` reads "emet_session_open with the startup's load_id, after
+  every startup page". On a live-sized store the five pages, as received, are 17,301, 17,864,
+  13,778, 14,033 and 5,560 bytes; every page stays within the 18,000-byte page budget, and a
+  test checks it. The bot session loop in `docs/BOTS.md` starts with `emet_initialize {}` and
+  every page it names (`{"page": "all"}` only on a host known to read long results whole) and
+  opens with that `load_id`; the README, the paste-in block in `docs/BOOTSTRAP.md` and the bot
+  handoff template say the same.
+- `docs/DEPLOY.md`'s rollback note says what each `EMET_SESSION_GRAPH` value does on the
+  older build, and `docs/ROADMAP.md` records the enforce-only monorail and paged startup as
+  deployed.
+
+### Fixed
+
+- In `emet_gaps`, session-order results now show the source tag of memory saves and
+  revisions (they showed none before), and flagged document writes now name the document.
+- The README and the permissions guide now give the correct tool count: 28 tools, 12 of
+  them read-only.
+- The "Known gaps" entry about the scheduled weekly intake is rewritten in plain words and
+  matches how such writes are handled now.
+- The upstream project EMET is built from can no longer be reached at its old address.
+  The credit is kept as it was, with a note that the link is unavailable.
+- The README, the setup and guided-setup guides, the deploy guide and the message at the end
+  of setup no longer say to set a distinct `EMET_SOURCE_TAG` per host. On a server several
+  hosts share it stays unset: each host passes its own `source`, and `EMET_SOURCE_TAGS`
+  registers the tags, as `.env.example` already said. A default tag is only for a server one
+  host uses.
+- `emet_session_close` takes `source`, and the close is never refused for it. The close is
+  attributed only to a registered tag that wrote the session (the `source` passed, else the
+  server's default tag); otherwise it warns and says why: no tag, a tag not registered in
+  `EMET_SOURCE_TAGS`, or a tag that did not write the session. The tag is echoed capped at
+  whole characters. It used to warn on every close on a server with no default tag, even when
+  the host passed a registered tag of its own.
+- The bot handoff template's session loop now says to fetch every startup page, with
+  `{"page": "all"}` only on a host known to read long results whole, as `docs/BOTS.md` does.
+- The setup interview's note for a store that is already initialized now says a second
+  `emet_setup_complete` is refused unless `reissue: true` is passed. It said a re-run would
+  create a new version.
+
+### Security
+
+- Updated three dependencies to patch releases that fix moderate advisories: `fast-uri`
+  3.1.8, `hono` 4.13.12 and `ip-address` 10.7.3. No direct dependency changed.
+- New tests confirm that a code is refused before any lookup when both access doors are
+  off, that the owner's sign-in still refreshes, and that a database outage is reported
+  as a server error (500), not as a bad sign-in.
+
+## 0.1.0 - 2026-10-02
+
+The first public release.
+
+### Added
+
+- **A shared memory server for MCP.** One store in MongoDB (Atlas or self-hosted) that
+  several hosts can read and write: desktop and command-line apps, browser and phone
+  clients, and assistants from other vendors.
+- **Six memory layers and a word-for-word transcript tier.** Curated memories and the
+  conversations behind them are kept apart, so neither can quietly overwrite the other.
+- **Every write is checked.** Each write is read back and compared before it is reported
+  as saved. Each memory carries a content digest (and a signature, when a signing key is
+  set), and each layer forms a hash chain that `emet_gaps` can walk end to end.
+- **Corrections without deletion.** Memories and transcripts are corrected by superseding
+  them, never by editing or deleting them. Documents can be changed, but every earlier
+  version is kept in their history, and they are retired rather than deleted.
+- **A versioned document store** with templates, a conformance check and a full revision
+  history.
+- **Session start and close.** One call to `emet_initialize` gives the assistant everything
+  it needs at the start; `emet_session_open` starts the transcript. Closing a session
+  requires receipts for each record it was supposed to update.
+- **A session-order check** that watches the order of a session's writes. It ships in
+  report mode: it flags what it would refuse and blocks nothing.
+- **Local or remote.** The same code runs as a local stdio server or as a remote HTTP
+  server with OAuth sign-in, protected by a passphrase you choose.
+- **Two optional access doors, both off by default.** EMET Guest Access gives a second
+  person read access; EMET Member Access gives a new person read and write access, never
+  the owner's identity. Each person's sign-in only refreshes while its own door is on.
+- **Source tags.** Every write records which host made it. Registering the allowed tags
+  with `EMET_SOURCE_TAGS` turns on the guards against unknown or mistyped tags.
+- **Least-privilege database access.** A script and guide for a database role that can add
+  and update records but never delete them.
+- **Secrets masked before storage.** Common secrets such as API keys, tokens and
+  passwords in connection strings are masked in content before it is saved.
+- **Clear sign-in errors.** An expired, revoked, replaced or unknown sign-in is answered as
+  a sign-in problem (401 or 400) that tells the app to sign in again, not as a server error.
+- 28 tools, 12 of them read-only, each labelled with standard MCP hints so a host can tell
+  reads from writes (and, if it chooses, skip approval for reads).

package/CHARTER.md

@@ -0,0 +1,125 @@
+# EMET ARCHITECTURE CHARTER
+
+**Record control:** id `CHARTER.md` · revision: the store's version governs · status: IN FORCE · approved: user · 2026-09-11 · a decision record · revised with the user's approval 2026-09-15 (the consolidated revision, a decision record) · revised at the user's word 2026-09-23 (parked items named at startup; §3 commitment 8, §6 item 3; a decision record) · revised with the user's approval 2026-09-27 (pending lessons named at startup; blocked-close cap and scope at close; §6 items 3 and close; a recorded lesson) · revised with the user's approval 2026-09-29 (the aleph named as the integrity verifier; Guardrails & Monorails, with switches; the database boundary; the per-exchange transcript; the user as final authority; §1, §3 commitments 1, 2 and 9, §4, §6, §8, §10; a decision record) · revised with the user's approval 2026-09-30 (the admission test: four questions before anything is built, DMADV while in design, DMAIC once stable; §3 commitment 6; a decision record) · Tier 1 · owner: the user · decision record: the owner's
+**Written:** 2026-09-10, session `2026-09-10_morning-mobile-init`, source `mobile`
+⚠ **Public document once the repository is public.** The disclosure line (a decision record) must be drawn before publication. This document states structure and intent only — no implementation specifics.
+⚠ **§1 is in the user's words (2026-09-11); attorney review pending** (claim language is on that agenda).
+
+---
+
+## §1 PURPOSE AND INTENDED USE — the user's words, 2026-09-11 (procedural entry of that date) · attorney review pending
+
+**EMET is a persistent contextual memory MCP server that gives an AI assistant a consistent, user-tailored identity, with the option of plug-in customization of interaction style and function.** It gives the assistant a durable, verifiable record that survives across sessions, devices and host applications — who the assistant is, who it serves, what has happened, what has been decided, and where the work stands — so each session continues from the last instead of starting over.
+
+**It is designed with the understanding that it may be used in support of processes and environments operating under ISO quality-management standards such as ISO 9001 and ISO 13485.** Its records are attributable, versioned, never deleted and integrity-checked, and its documents are controlled: every templated write is checked against the template in force, a write that fails that check is marked and kept as the current revision, and a later revision or an acceptance clears the mark. EMET itself holds no certification and claims no conformity. An organization that uses it within its quality management system remains responsible for that system, including validating EMET for its intended use there (ISO 13485 §4.1.6).
+
+**A record that is never deleted or edited must also be accurate** (the user, 2026-09-29: *"It is integral for the ISO data that is never deleted or edited to be accurate"*). Permanence without accuracy only preserves an error. So every write is verified as recorded accurately before it is confirmed, and every later read is checked against what was recorded — the aleph (§4).
+
+**The same expectation governs how EMET is built.** Its code — JavaScript on Node.js today, and any language it is implemented in later — and its development processes are held to it: every change is version-controlled, tested by an automated suite, released deliberately, and verified live with a real call before it is called done, and the history of what changed is kept. That evidence is what an organization's own validation can draw on.
+
+**It is designed first for neurodivergent users** (ADHD, autism, AuDHD), for whom lost context and re-explaining carry a higher cost. It works for anyone.
+
+**Intended user:** one user working with an AI assistant through hosts that support the Model Context Protocol.
+
+**Not intended:** EMET is not a medical device. It does not diagnose, treat or monitor any condition and is not a substitute for clinical care. It does not control what an assistant says; it records what is written to it.
+
+## §2 SCOPE
+
+**In scope:** the record — memory layers, verbatim transcripts, controlled documents, the rules for writing, reading and correcting them, and the standing definition of the assistant.
+**Out of scope:** the model's behaviour, the host application, and the conversation itself. **EMET sees what is written to it, not what is said.** No control in EMET can stop an assistant telling a user something false; what EMET can do is make the record honest, attributable and checkable.
+
+## §3 DESIGN COMMITMENTS
+
+1. **Verification over assertion.** Every write is read back by the aleph and verified before a receipt is returned, and every later read is checked against what was recorded. A claim of completion needs evidence.
+2. **Nothing is deleted.** Entries are superseded, documents are revised or retired, events are never rewritten. Prior versions are retained. **This holds below the server too:** the database login EMET runs under has no permission to remove the record, so a fault in the server cannot delete it either.
+3. **Provenance is part of the memory.** Every write names the host that produced it, and assertions point to their source.
+4. **State a rule once.** Rules held in code are pointed to, never copied into documents.
+5. **Controls, not reminders.** Where a rule matters, a mechanism enforces it; an instruction to be careful is not a control.
+6. **Over-engineering is a defect — the check comes before the build.** Anything may be considered; nothing is built until it answers four questions. **What failure does it fix, and where is it in the record?** An observed failure, not an anticipated one. **What does it replace or retire?** An addition that replaces nothing clears a higher bar. **How will we know it worked?** One measure, checked in a pilot. **What holds it once it works?** A control, not a reminder (commitment 5). What cannot answer all four stays a seed. Additions are gated before they ship, not trimmed after (the user, 2026-09-30: *"I dont want us to become an oreborous eating its tail with proposed additions to then reduce afterwards"*). **The method follows the product's stage** (the user, 2026-09-30: *"The variant works for now, dmaic for once stable"*): while EMET is still being designed, work runs DMADV — Define, Measure, Analyze, Design, Verify. Once it is stable, work runs DMAIC — Define, Measure, Analyze, Improve, Control.
+7. **No implied conformity.** EMET puts recognised quality-management practice into operation. It claims no certification.
+8. **Out of sight is out of mind.** For users with time blindness or object impermanence, an item not named does not exist. At every session start the server lists the half-finished, dated, open, undecided, and parked rows it can read (`named_items` on `emet_initialize`), and the session says those names. A section that is not a table is marked unread, and an empty list is not a reason to skip the document. A count is the assistant's check, never a substitute for the names. **Parked items are named too, in a list of their own** — what the user deliberately set aside drops out of mind as fast as what they forgot, so parked means out of the way, never out of sight; each is named with what brings it back, and nothing is asked of it (the user, 2026-09-23: *"for ND it's out of sight out of mind"*). Naming the user's own items is external working memory, not unrequested instruction. This commitment is part of the floor.
+9. **Guardrails & Monorails.** Judgment and process are kept apart (the user, 2026-09-29). **Guardrails** — the floor, the character, the served instructions — bound a field in which the assistant uses its judgment freely. **The monorail** — the session's order of work — carries it from one field to the next on a track the server checks, which it cannot leave. Where the flow must fork, a **switch** at the junction routes it to the guardrail space that fits: a small logic unit in EMET, tripped only by its condition, like a transistor, with no hosted model and no outside service (the user, 2026-09-29). The track throws the switch; the assistant does not choose whether to follow the protocol or which branch to take. Each switch is designed for its junction, from the function it serves and the flow of information and tasking through it. This is commitment 5 applied to the order of a session.
+
+## §4 ARCHITECTURE — components and their roles
+
+| Component | Role | Where its rules live |
+|---|---|---|
+| **The floor** | How the assistant engages the user, regardless of configuration. Cannot be edited by setup or by the user. The guardrails' base. | Server code |
+| **Bootstrap documents** | The assistant's standing definition: identity, character, the user, available tools. Without them the assistant is a hollow golem — it functions, but only as a transcriber. | Document store, built at the first-run interview |
+| **SHEM** | The name the user inscribes — who the assistant is, held in the identity document. In the golem lore the inscription and the Name are separate: EMET is the truth written on the substance; the SHEM is what animates it. EMET supplies the substance and the record; the user supplies the SHEM. Its spoken form is the user's identity phrase (§6). | Identity document, written at the first-run interview |
+| **Tier 1 — memory layers** | Curated meaning, in six layers: identity, semantic, episodic, procedural, meta, working. Queried first. | Layer charter, server code |
+| **Tier 2 — verbatim transcripts** | The word-for-word record of each session, appended one exchange at a time as the session runs. **Independent of Tier 1 by design** — the independence is what makes it a second line of inquiry. Tier 1 entries point into it by session and span; timestamp is the fallback bridge. | Server code |
+| **Document store** | Controlled documents: the board, handoffs, threads, seeds, working papers, bootstrap, this charter. Versioned; every prior revision archived. | Template standard (`templates/STANDARD.md`) |
+| **The write path** | The single entry for every write. Masks secrets, attributes the source, marks what the writer left out, digests content and metadata, and hands the write to the aleph before returning a receipt. Refuses a semantic or procedural entry with no source (2026-09-29): a durable claim must point to where it was said. Validates every templated document against the template in force and marks nonconformance for audit and review (live 2026-09-11). | Server code |
+| **The aleph** | **Verifies memory integrity.** At the write: that it was recorded accurately — every write is read back and compared before any receipt, and a store that does not hold what was sent is reported as that, never as an ordinary failure. At every later read: that it is still what was recorded — each entry's digests, signature and place in its layer's hash chain are checked, and the whole chain can be walked by any host. Named for the first letter of *emet*: erase it and *met*, dead, remains — a memory that answers without verification. | Server code |
+| **The monorail (session graph)** | Checks the order of each session's writes on every host, with no host hook: a session is opened before it is written to, no exchange is skipped, the handoff comes last, nothing is written after a complete close. Each write is told the next stop. Where a flow forks, a switch owned by the track, never the assistant, picks the branch to a guardrail space (designed 2026-09-29; not yet built). Every check is stored with its time as a lab result. Enforce only since 2026-10-03: a skipped step is refused, and there is no report mode or off switch. | Server code |
+| **The database boundary** | The login EMET runs under may add and update, never remove the record (2026-09-29). Commitment 2 is enforced by the database as well as by the server. | Database role, defined once in server code |
+| **The read path** | Returns entries with their integrity status, verified by the aleph. A superseded entry surfaces marked, naming what replaced it and the date it ended (decided 2026-09-13); a lookup by any id in a supersession chain also returns the live end of the chain, so a cross-reference keeps resolving after every later revision (2026-09-15). An expired entry surfaces the same way, marked with its end date. Current entries come first in every order, including time order. Retired documents stay in the document list and the startup scan, after the current documents, marked with the date and what replaced them. Recall ranks by relevance and importance. Time order is `order: 'latest'`, or a standalone latest, newest, or most recent together with other words. Retained document revisions are readable in full. | Server code |
+| **Supplementary corpus** | Optional reference material loaded by the user, separate from memory. | Server code |
+| **Extension socket** | **Planned, not built.** Where a GEM (Guided Engagement Module) seats; a RUNE (Registered Utility Node Extension) is a tool etched into a GEM. All GEMs are built to a standard. **Precedence (decided 2026-09-11):** a GEM the user adds takes precedence over the floor's modifiable defaults — voice, pace, how much is explained — and any conflict is resolved with the user when the GEM is added. **No GEM reaches the floor's protections:** it may add depth that complements them, never remove or weaken them. No GEM, whatever its authorship or intent, may compromise the user — and that is enforced by the socket, not left to a GEM author's good faith (commitment 5). | To be written |
+
+## §5 HIERARCHY
+
+**Document hierarchy — four tiers.** Register: `templates/INDEX.md`.
+1. **Charter** — this document.
+2. **Procedures** — how a session runs; the floor and layer charter in code.
+3. **Work instructions and reference** — how to do a specific thing.
+4. **Forms and records** — templates, and the documents filled from them.
+
+**Order of authority when sources disagree:**
+1. **The user's current word** — on everything the floor leaves to the user.
+2. **The floor** — on what is owed to the user regardless of configuration.
+3. **The current controlled document** (board, thread) — on where things stand.
+4. **Tier 1 entries** — on what happened and what it meant.
+5. **Tier 2 transcripts** — on exactly what was said.
+A disagreement between sources is recorded, not silently resolved.
+
+## §6 FLOW
+
+**Session start — reads:** initialize → open the session → read the board and the handoff → scan seed triggers.
+**Session start — what the user sees, in this order:**
+1. **EMET's line:** *"Truth stands. Memory connected."* — or, if the server did not answer, *"MET — the aleph is missing. Memory not connected."* (EMET's line claims truth and connection, never life; the user's name does the animating.)
+2. **The user's identity phrase**, if one is set — the SHEM spoken, confirming the assistant's identity loaded.
+3. **The named items** — every half-state row, every dated item in the next seven days, every open item the user owns with its next action, and anything left undecided last session; drawn from the board, the user's calendar and any active schedule. **Then, under its own heading, every parked item** — one line each with what brings it back; named, never pressed (commitment 8). **Then, under its own heading, every pending lesson** — a correction the record holds three or more times with no disposition; one line each, named, never pressed. A lesson is settled by a check in code, a rule landed in a controlled document, or a written ruling that it cannot be checked; the server computes the list (`lessons_pending`, 2026-09-27) so the next conversion of advice into a control (commitment 5) is a standing decision, not a count.
+4. **The board's counts as the check, never in place of the names.**
+5. **What is actually available in this session**, confirmed before any capability is claimed.
+6. Then any question. **Never open with a question alone.**
+**During work:** append each exchange to the transcript after every reply, as it happens · every write names its session and exchange, and is told the next stop · search the record before answering anything with prior context · write decisions when they are made, with the user's words · write with provenance · verify each write by its receipt.
+**Session close — this is the one place the order is stated:** update working documents → session record in memory → board → verbatim transcript, confirmed complete (it was appended as the session ran) → **handoff last, in one write** → confirm every artifact landed. The handoff is last because its close verification attests to the other artifacts; written earlier, it attests to things that do not yet exist and needs a patch afterwards. If a session ends mid-close, the prior handoff stands and the board and session record already carry the session. **A close that fails its check is returned with a scope per missing item — what may be touched to clear it and nothing else — and the third blocked close on one session escalates: the assistant stops, hands the user the list, and waits for their word. The counter resets only with a new session (rule in code, 2026-09-27).** **The server checks this order on every write (the monorail, §4):** a skipped step is refused. Enforce only since 2026-10-03; there is no report mode.
+**Correction:** a layer entry is superseded by a revision that stands alone · a document is revised or retired · an event is never rewritten; a later entry corrects the reading of it.
+
+## §7 DOCUMENT CONTROL
+
+Governed by `templates/STANDARD.md`. Base templates must be followed and may be expanded, never loosened. Every templated write is validated; a nonconforming write is **marked for audit and review**, never silently accepted and never discarded.
+
+## §8 ROLES
+
+- **User** — owns the intended use, makes decisions, sets standards for how the assistant works. **The final authority** (the user, 2026-09-29: *"AI assistants are subordinate to the user. While it is a collaborative relationship without a sycophantic role by the AI, the user is the final authority"*).
+- **Assistant** — executes, verifies, records. Recommends and disagrees plainly; never records its recommendation as the user's decision.
+- **Host** — the application running the assistant. Every host writes under its own source tag.
+- **EMET** — the record, and the enforcement of whatever code can enforce.
+
+## §9 CHANGE CONTROL
+
+This charter changes by revision, with the user's approval. Rules held in code change by release: committed, deployed, and verified live with a real call — **a pushed fix is not a live fix.**
+
+**This charter is locked the same way as the base templates** (`templates/STANDARD.md` §9a, L1 — decided 2026-09-11). It ships with the release and the server reads it from there; any copy in an install's store is for reading, not authority, and a store copy that differs from the shipped copy is marked nonconforming. `emet_initialize` points to it in every state, **including a new store before the first-run interview**, so the floor, this charter and the startup instructions are present before any SHEM is placed.
+
+## §10 LIMITS, STATED PLAINLY
+
+- Retrieval is not guaranteed complete, and an assistant's behaviour is not reproducible run to run. **EMET's record is deterministic and verifiable even where the assistant is not** — that is the claim, and its limit.
+- EMET is derived from the CASCADE memory server (MIT licence); attribution is maintained in the repository.
+
+**Where an AI assistant can be controlled at all, and which of those places EMET is** (the user's assessment, 2026-09-14; placed here at his direction 2026-09-15 so the charter is one complete record). Three places:
+
+1. *Training.* The model's maker sets what the model tends to do. Out of reach of any user, host or server.
+2. *The host.* The application running the assistant. Some hosts expose deterministic hooks — before a tool call, after an output — that can block an action regardless of what the model intended. Where a host offers them, that is real enforcement, and it belongs to the host. Many chat hosts expose none. **EMET depends on none of them** (the user, 2026-09-29): it must run the same for any assistant, on any device, with no model- or host-specific tool.
+3. *EMET — the write boundary.* EMET sees exactly one thing: the calls the assistant makes to EMET's own tools. It never sees the user's message and never sees the assistant's reply (§2). **Within that boundary it checks each call and, since 2026-09-29, the order of the calls** (the monorail) — so a skipped exchange or an early handoff is caught on every host, without a hook. This does not widen what EMET sees.
+
+**Why "delivered at session start" is not "enforced".** The floor and the character document reach the assistant through `emet_initialize` and are then context — text the model reads before generating. Instructions in context shape a probabilistic generation; there is no point in the process where a rule is checked and passed or failed. An assistant that drifts from the floor has not weighed it and decided to step over it; it has generated a reply in which the floor did not carry enough weight. This decides which fixes work: restating a rule more forcefully adds no check, and a reminder is not a control (commitment 5). **Drift is not a decision to violate.**
+
+**What EMET enforces** is everything that passes through the write path, deterministically (§4): the receipt, and the aleph's verification behind it that the record holds exactly what was written; the source tag, the provenance pointer and origin on assertions; template validation on documents; supersession in place of deletion, held by the database as well as the server; masking of secrets; and the order of a session's writes. The forms of drift that reach the record are therefore caught at the door — a task row opened without the user's words behind it, an assistant's reading written into the field that holds the user's quote, an assertion with no origin, a turn left out of the transcript.
+
+**What EMET does not enforce.** It cannot stop an assistant saying something unfounded to the user; nothing at the memory layer can. It cannot stop an assistant proposing work the user did not ask for, unless the proposal is written to the record, where it can be marked. It cannot verify that a stored assertion is true, only that it is attributed and sourced, and that the record holds it exactly as it was written. It filters writes, not responses.
+
+**What this means for a user.** The controls that catch conversational drift are the user's own questions, a host's hooks where they exist, and — for a high-stakes session — a second assistant asked to check the first. EMET's contribution is that when drift happens, the next session can see it, attribute it and correct the record without erasing the evidence. That is the whole of its jurisdiction, and it is the part that survives a change of model, host or vendor.

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025-2026 C.I.P.S. LLC
+Copyright (c) 2026 Dreamforge Studio LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.