pi-jarvis 1.6.0 → 1.7.0

package/AGENTS.md

@@ -2,7 +2,7 @@
 
 ## Project Scope
 - `pi-jarvis` is a Pi extension that opens a `/jarvis` side-conversation overlay.
-- Core runtime files: `index.ts`, `side-session.ts`, `native-mcp.ts`, `overlay.ts`, `overlay-layout.ts`, `draft-editor.ts`, `transcript-viewport.ts`, `model-picker.ts`, `jarvis-config.ts`, `session-ref.ts`.
+- Core runtime files: `index.ts`, `side-session.ts`, `native-mcp.ts`, `overlay.ts`, `overlay-layout.ts`, `draft-editor.ts`, `transcript-viewport.ts`, `jarvis-branding.ts`, `model-picker.ts`, `jarvis-config.ts`, `session-ref.ts`, and `memory-{types,config,content,store,service,extension}.ts`.
 - Current baseline: Pi 1.0.0 (`@earendil-works` packages), Node.js >=22.19.0. Older Pi hosts are not supported.
 
 ## Current `/jarvis-model` and `/jarvis-thinking` Behavior
@@ -15,7 +15,7 @@
 - `/jarvis-thinking [--project|--global] auto|follow-main|off|minimal|low|medium|high|xhigh|max` stores a scoped thinking override without changing the main session thinking level.
 - `/jarvis-thinking [--project|--global] clear` removes that scope's thinking override so fallback applies.
 - Resolution order is: project config, then global config, then built-in defaults (`follow-main` for model, `auto` for thinking). Global writes never override an active project setting.
-- Config writes use atomic same-directory replacement. I/O errors must not trigger malformed-JSON recovery. Cross-process concurrent config writes are not locked.
+- Config writes use atomic same-directory replacement. Malformed shared JSON requires manual repair: model/thinking set/clear must never replace/delete it and reset unknown memory privacy controls. Keep I/O errors distinct and parser input snippets out of UI errors. Legacy model/thinking cross-process writes remain unlocked.
 - `auto` thinking follows main only when `/jarvis` follows the main model; pinned `/jarvis` models default to thinking `off`.
 - `follow-main` thinking follows the main thinking level regardless of model selection, except xAI `/jarvis` models force thinking `off`.
 - `/compact`, `/tree`, and `/new` entered inside `/jarvis` operate on the isolated `/jarvis` side-session, not the main Pi session.
@@ -34,6 +34,13 @@
 - Queue count excludes active work; processing includes boot and complete queue settlement. Keep activity separate from scrollback and never replay uncertain sends.
 - Bound overlay history (500 entries, 512K UTF-16 units total, 64K per entry) with explicit omission notices; never truncate persisted history.
 
+## Branding intro (1.6.1)
+- The first overlay for each main-session ID in the loaded extension shows a 1.8-second neon/chrome ASCII sweep, then returns to the compact UI. Reopen, side `/new`, tree navigation, and returning to an already-seen main session must not replay it. Reload/restart resets this in-memory bookkeeping.
+- The intro is decoration, never a boot/queue gate. Keep editor, permissions, and activity available. Input dismisses it without being consumed; paste framing still precedes shortcuts. Confirmations and warnings/errors preempt it.
+- Use a bounded, unreferenced, lazily started timer; stop on dismissal, expiry, or disposal. No blinking, flashing, terminal-clearing commands, transcript entries, or persisted session changes.
+- Suppress with `PI_JARVIS_NO_ANIMATION=1`, non-empty `NO_COLOR`, or `TERM=dumb`. Use compact/no intro on small terminals and readable palettes for light themes and 256-color output.
+- `jarvis-branding.ts` owns the original wordmark. `npm run render:branding` regenerates README SVGs with local renderer fixtures, not live provider/session data. Label fixture previews honestly.
+
 ## Native MCP (1.6.0)
 - Use Pi's root-exported native factories, not private registry/runtime/transport internals. Jarvis owns separate configured-server connections; main-only extension registrations are not inherited.
 - No native startup/credential expansion while initially off. Respect project trust, enabled states, native tool exposures, and live Repo tools permission for direct/deferred/codemode/resource execution.
@@ -42,6 +49,17 @@
 - Keep server administration in main Pi. Disable codemode model helpers (`models: false`); preserve independent Note main/Redirect gates and the overlay-owned bridge subscription.
 - Tests use temporary agent/workspace directories and local fixture servers only; never start real user MCP servers or resolve real credentials during validation.
 
+## Shared memory (1.7.0)
+- Main Pi and the isolated Jarvis SDK session explicitly mount one shared local service. Memory is enabled by default in trusted projects, independently of Repo tools, Note main, Redirect, and overlay open/close. It can share historical facts even when bridge delivery is off; it never steers or queues work.
+- `/jarvis-memory` reports status; `help` documents controls. `[--global|--project] on|off|capture on|off|recall on|off|clear` controls default to GLOBAL (unlike model/thinking). Per-field project > global > defaults, except global enabled=false is a master kill switch. Untrusted projects and config errors pause all memory. Full off means no memory-record reads/capture/injection/tool execution; retain data. Explicit admin inspection still requires enabled memory; capture/recall-only pauses do not block manual commands.
+- Inside the overlay, `/memory …` and `/jarvis-memory …` execute immediately without model/boot/queue work. `clear` removes settings, never data; `forget-all --confirm [--global|--all]` defaults to only the current project's records. Data scope flags follow the action.
+- Disclose capture/recall before first use and only then persist the global disclosure marker. No silent historical import, background providers, embeddings, real user credential access, or real MCP servers during tests. Isolate every test's agent/workspace directories.
+- Capture only new finalized user/assistant text, not thinking/tool/custom/system/attachment data or aborted/error output. Stage only event metadata (max 256 anchors); resolve at turn/settlement boundaries from at most 1,024 newly persisted parent-chain entries, stopping before the old leaf. Never archive intermediate message_end payloads before later redaction hooks. Discard pending anchors on revocation, session/tree change or disposal; never backfill. Secret filtering is best-effort, not a guarantee; reject suspected secrets in curated notes. Cap text at 16 KiB UTF-8; omit oversized archive captures, reject oversized notes. Archive retains newest 10,000 records; curated notes cap at 1,000 without automatic deletion.
+- Keep auto recall scoped to global + canonical current cwd; explicit all-project search is supported. Request-local context injection is bounded to 6,000 bytes of untrusted record JSON plus notice; search results 12,000 bytes with excerpt/omission markers. Never persist automatically injected context via appendEntry/sendMessage or treat stored instructions as authority. Explicit tool calls/results still follow normal Pi persistence; don't promise that disabling/forgetting erases earlier tool results or already-viewed output.
+- Store is lazy local SQLite under the active agent directory (`extensions/pi-jarvis-memory/memory.sqlite`), not a project-selected path. SQLite coordinates record writers; memory settings use atomic cooperative locking that legacy model/thinking writes do not participate in. Fail closed on malformed settings; never repair automatically.
+- Memory guidance is also request-local: use a custom advisory so Pi's later forced-prompt projection cannot discard it. Preserve other prompt/tool state; a mid-turn disable removes both advisory and recalled records from future requests.
+- Model tools recheck live trust/settings/cancellation and permission generations at execution, including captured definitions. Broadcast observed policy changes across mounted lanes and revoke per-binding generations at session/tree boundaries; don't promise live push delivery across processes. Model forget requires cancellable human review and transactionally compares the reviewed version. Tombstones prevent identical event/title resurrection, not every semantic mention; Pi transcripts, backups and already-sent context remain. Do not promise encryption, a sandbox, or forensic erasure.
+
 ## Git and Release Policy
 - Every new commit MUST have an annotated **stable version tag `vX.Y.Z`**. No `dev`, alpha, beta, release-candidate, build-metadata, or SHA-only tags. This is a released extension, not a prerelease channel.
 - Before committing, choose the next unused stable version and update package metadata, lockfile, README, and a dated changelog entry together. Tag every commit, including intermediate and merge commits; never leave a new commit untagged. Run `npm run check:tags`, then push the commit and version tag atomically. Do not move or replace existing tags or rewrite shared history.

package/README.md

@@ -2,28 +2,51 @@
 
 <div align="center">
 
+<img src="https://raw.githubusercontent.com/crustyhacker/pi-jarvis/main/docs/assets/jarvis-logo.svg" alt="JARVIS — Pi / A second lane of thought. Cyan, violet, and pink ASCII chrome." width="720">
+
 ## A cinematic side-conversation overlay for Pi
 
 **Open a second lane of thought without derailing the main session.**
 
 `pi-jarvis` adds `/jarvis`: a polished overlay where you can ask for status, inspect the repo when you explicitly allow it, and send a quiet note or a confirmed redirect back to the main lane.
 
+[![CI](https://img.shields.io/github/actions/workflow/status/crustyhacker/pi-jarvis/ci.yml?branch=main&style=for-the-badge&label=CI)](https://github.com/crustyhacker/pi-jarvis/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/pi-jarvis?style=for-the-badge&color=7c3aed)](https://www.npmjs.com/package/pi-jarvis)
 [![license](https://img.shields.io/badge/license-MIT-111827?style=for-the-badge)](./LICENSE)
 [![Pi extension](https://img.shields.io/badge/Pi-extension-06b6d4?style=for-the-badge)](https://github.com/crustyhacker/pi-jarvis)
 [![TypeScript](https://img.shields.io/badge/TypeScript-powered-2563eb?style=for-the-badge)](./package.json)
 
-<p><strong>Current version:</strong> 1.6.0</p>
+<p><strong>Current version:</strong> 1.7.0</p>
 
 <p>
+  <strong>Shared persistent memory</strong> ·
   <strong>Persistent side session</strong> ·
   <strong>Live main-session awareness</strong> ·
-  <strong>Permission-gated tools</strong> ·
+  <strong>Opt-in local tools + native MCP</strong> ·
   <strong>Safe redirect flow</strong>
 </p>
 
 </div>
 
+<details>
+<summary>Plain-text wordmark</summary>
+
+```text
+     _    _    ____ __     _____ ____
+    | |  / \  |  _ \\ \   / /_ _/ ___|
+ _  | | / _ \ | |_) |\ \ / / | |\___ \
+| |_| |/ ___ \|  _ <  \ V /  | | ___) |
+ \___//_/   \_\_| \_\  \_/  |___|____/
+
+       PI / A SECOND LANE OF THOUGHT
+```
+
+</details>
+
+![Jarvis compact overlay, rendered with deterministic demo data](https://raw.githubusercontent.com/crustyhacker/pi-jarvis/main/docs/assets/jarvis-overlay.svg)
+
+*Renderer preview with a custom dark palette and demo conversation—not a live provider session. Your Pi theme controls the normal overlay.*
+
 ---
 
 ## The pitch
@@ -55,12 +78,13 @@ The main Pi session should stay on the critical path.
 
 | Capability | What you get |
 |---|---|
+| **Shared memory** | Main Pi and Jarvis remember useful discussions across sessions; enabled by default, with global/project controls and a master off switch |
 | **Persistent side lane** | `/jarvis` keeps its own isolated conversation state and restores prior side-session history |
 | **Live awareness** | Jarvis sees the current main-session summary plus a delta since the last `/jarvis` turn |
-| **Permission-gated tools** | Local `read`, `bash`, `edit`, and `write` stay off until you enable them |
+| **Permission-gated tools** | Local `read`, `bash`, `edit`, `write`, and configured native MCP stay off until you enable Repo tools |
 | **Safe main-session handoff** | `Note main` is quiet; `Redirect` is confirmation-gated |
 | **Independent model control** | Follow the main model or pin `/jarvis` to a separate model |
-| **Cleaner UX** | Compact header, scrollable history, multiline drafts, and independent activity/queue feedback |
+| **Cleaner UX** | A one-time neon ASCII intro, then compact diagnostics, scrollback, multiline drafts, and independent activity/queue feedback |
 
 ---
 
@@ -71,7 +95,10 @@ flowchart LR
     U[You] -->|primary work| M[Main Pi session]
     U -->|open /jarvis| J[Jarvis overlay]
     M -->|summary + recent delta| J
+    M <-->|independent memory controls| S[Shared local memory]
+    J <-->|independent memory controls| S
     J -->|Repo tools enabled| R[Local tools\nread • bash • edit • write]
+    J -->|Repo tools enabled| C[Configured native MCP\nside-owned connections]
     J -. Note main .-> M
     J -. Redirect after confirmation .-> M
 ```
@@ -125,6 +152,8 @@ Requires **Pi 1.0.0** and **Node.js 22.19.0 or newer**. Version **1.6.0** suppor
 ### 2) Restart or reload Pi
 
 `pi install` registers the package automatically. For local development, build and load `./dist/index.js` with `pi -e ./dist/index.js`.
+**New in 1.7.0: shared memory is enabled by default in trusted projects**, including main Pi even if you never open the overlay. A first-use notice explains capture and recall. Already using another memory extension? Run `/jarvis-memory off` before your first prompt; this disables both main and Jarvis memory without deleting anything.
+
 ### 3) Open Jarvis
 
 ```bash
@@ -139,8 +168,8 @@ Or open it and send the first message immediately:
 
 ### 4) Turn on more power only when you want it
 
-- leave `Repo tools` off for pure context / analysis
-- turn `Repo tools` on when you want local `read`, `bash`, `edit`, and `write`
+- leave `Repo tools` off for context / analysis without repository or MCP access; shared memory has separate controls
+- turn `Repo tools` on when you want local `read`, `bash`, `edit`, `write`, and configured native MCP capabilities
 - turn `Note main` on when you want Jarvis to quietly message the main session
 - turn `Redirect` on when you want Jarvis to propose a redirect that you still explicitly confirm
 
@@ -175,6 +204,9 @@ Sets the thinking level used by `/jarvis` without changing the main session thin
 ### `/jarvis-thinking [--project|--global] clear`
 Removes the selected scope so `/jarvis` thinking falls back through the remaining config layers to the built-in `auto` default.
 
+### `/jarvis-memory`
+Reports shared-memory status. Use `/jarvis-memory help` for controls and data-management commands. Memory controls default to **global**, unlike model/thinking controls. See [Shared memory](#shared-memory) below.
+
 ### Side-session commands inside `/jarvis`
 The `/jarvis` input handles a small set of built-in commands against the isolated side-session:
 
@@ -183,6 +215,74 @@ The `/jarvis` input handles a small set of built-in commands against the isolate
 - `/tree <entry-id>` navigates the `/jarvis` session tree to that entry.
 - `/tree --summarize <entry-id> [instructions]` navigates and summarizes the branch being left.
 - `/new` starts a fresh `/jarvis` side-session without changing the main Pi session.
+- `/memory …` or `/jarvis-memory …` manages shared memory immediately, without sending a model prompt or waiting for queued side work. Initial forms such as `/jarvis /memory off` are also handled locally, without booting a side session.
+
+---
+
+## Shared memory
+
+Main Pi and Jarvis use **one local memory service**, independent of the overlay lifecycle. Useful Jarvis discussions can inform a later main session and vice versa—even when `Note main` is off. Memory does not steer or queue messages into the other session; it supplies historical context when recalled. Close/reopen, `/new`, and project changes do not erase it.
+
+### What is remembered
+
+- **Conversation archive:** only newly finalized user/assistant text observed after loading this feature, labeled with project, main/Jarvis lane, session ID, event identity and timestamps. No silent historical import or reconstruction from old session files.
+- **Curated notes:** your active model can save concise preferences, corrections, project decisions and references during normal foreground work. Stable scoped titles update/deduplicate notes. You can save or edit notes explicitly too. Curation depends on the model choosing the tool; it is not a separate background summarizer.
+- **Bounded recall:** a small request-local selection of global/current-project notes and matching conversation excerpts, using local keyword search. Other projects are available through explicit `search --all` or the model's cross-project search tool. Project scope uses the canonical working directory, not a remote repository name; separate worktrees remain separate scopes unless a note is global.
+
+There are **no embeddings, background model calls, telemetry, or memory-server connections**. Retrieval and saving tools can add normal foreground model turns/tokens. Recalled text is sent to the active model as untrusted historical data, not instructions. Automatic recall is capped at 6,000 UTF-8 bytes of record JSON plus a short notice; tool search results are capped at 12,000 bytes with explicit excerpt/omission markers. Automatically injected memory guidance and recall are request-local, not appended to Pi's persisted transcript. Explicit memory-tool calls/results are recorded normally by Pi and may contain saved facts; model replies may repeat them too.
+
+### Controls
+
+```text
+/jarvis-memory                         # status, without reading stored memories
+/jarvis-memory off                     # global MASTER OFF for main + Jarvis
+/jarvis-memory on                      # enable globally; project restrictions still apply
+/jarvis-memory capture off             # saving default off (project overrides apply)
+/jarvis-memory recall off              # recall default off (project overrides apply)
+/jarvis-memory --project off           # pause memory in this project
+/jarvis-memory --project clear         # remove this project's memory settings
+/jarvis-memory --global clear          # remove global settings, not stored data
+```
+
+`enabled`, `capture`, and `recall` default to `true`. Each field resolves project → global → default, **except global `enabled: false` is a master switch that no project can override**. Untrusted projects and unreadable/malformed settings pause all memory. Use `--project capture off` or `--project recall off` to pause that capability specifically here; inspect status for the effective setting. The full off switch means no capture, memory-record reads, injection, tool execution, or background work; existing data remains on disk. Even inspection requires re-enabling memory. Explicit management commands still work with only capture or recall turned off. Turning memory off does not erase facts/tool results already in the current conversation or already-viewed output.
+
+Controls share the existing settings files and preserve model/thinking/unknown keys:
+
+```json
+{
+  "memory": { "enabled": false }
+}
+```
+
+Place this in `<agentDir>/extensions/pi-jarvis.json` to disable memory before installation/startup (normally `~/.pi/agent/extensions/pi-jarvis.json`; honors `PI_CODING_AGENT_DIR`). Project overrides live in `.pi/jarvis.json`. Memory settings writes are atomic and use a bounded cooperative lock; legacy model/thinking writers do not share that lock, so avoid concurrent configuration changes. Corrupt shared settings are never automatically repaired or overwritten—even by model/thinking set or clear commands. Repair the JSON manually while preserving privacy settings. A crashed config writer can leave a `.memory.lock` file; remove it only after confirming no writer is running.
+
+### Inspect, edit and forget
+
+```text
+/jarvis-memory list                    # recent global/current-project records
+/jarvis-memory search deployment       # local keyword search
+/jarvis-memory search --all deployment # explicitly search every project
+/jarvis-memory show <id>
+/jarvis-memory remember --global Answer style | Prefer concise answers.
+/jarvis-memory remember Build choice | This project uses npm, not pnpm.
+/jarvis-memory edit <id> Replacement fact, preserving the note's scope/title.
+/jarvis-memory forget <id>
+/jarvis-memory forget-all --confirm     # this project's records only
+/jarvis-memory forget-all --confirm --global
+/jarvis-memory forget-all --confirm --all
+```
+
+Put data scope flags **after the action**. `list --global` and `search --global …` restrict results to global records; `show --all <id>` and `forget --all <id>` explicitly allow another project's record. Lists and searches are bounded; narrow your query to find older records. Model-requested deletion is limited to one current/global record and requires human confirmation; commands above are explicit user actions. Confirmation is cancelled on observed permission change, abort or disposal, and a concurrently changed record must be reviewed again. Settings are rechecked at operation boundaries; other processes do not receive a live push notification.
+
+### Storage and privacy
+
+The store is `<agentDir>/extensions/pi-jarvis-memory/memory.sqlite`, with SQLite transaction/WAL coordination across processes. It is opened lazily; Node 22/24 may print an experimental SQLite warning on first actual use. On POSIX, the owned directory is mode `0700` and database mode `0600`; this is **local plaintext, not encryption or a sandbox**. Backups of your agent directory may include it.
+
+Only newly finalized visible text is captured—not thinking blocks, tool results/calls, images, custom/system messages, failed/aborted assistant outputs, or old session files. Metadata-only event anchors are resolved after Pi's message-finalization/redaction hooks, at turn/settlement boundaries. Pending captures are discarded on permission/session changes or disposal, not replayed after re-enable. Recognizable credential blocks are omitted and common secret formats redacted, but **filtering is best-effort and cannot detect every sensitive detail**. Pause capture or disable memory for sensitive work. Notes containing detected secrets are rejected rather than silently changed. Oversized captures (over 16 KiB UTF-8) are omitted, not truncated into misleading facts; curated-note writes over that limit fail explicitly.
+
+Retention is bounded to the newest 10,000 captured messages and 1,000 curated notes. Archive rollover never truncates Pi's original history; notes are not automatically discarded at their limit. Forgetting tombstones the record identity so the same captured event/scoped note title is not automatically restored; an explicit `remember` command can restore a forgotten title. This is not semantic erasure of every mention: other records, original Pi transcripts, already-sent model context and backups may still contain the fact. SQLite deletion is logical, **not forensic secure erasure**.
+
+The combined live-record/tombstone budget is 100,000 identities: new identity saves fail at capacity rather than dropping deletion markers; existing records always reserve room for forgetting. First database open performs synchronous integrity checks and can briefly pause on a large archive. SQLite WAL files can temporarily grow while another process holds a reader snapshot; there is no strict total-directory disk quota. To completely reset/delete this local store without re-enabling memory, stop every Pi process using it, then remove only the `pi-jarvis-memory` directory yourself. This also removes tombstones, not original Pi transcripts.
 
 ---
 
@@ -208,7 +308,7 @@ Model and thinking settings resolve through the same config layers, then fall ba
 2. global config: `~/.pi/agent/extensions/pi-jarvis.json` or the equivalent path under a custom Pi agent dir
 3. built-in defaults: model `follow-main`, thinking `auto`
 
-Global writes do not displace an existing project override. Config writes use same-directory atomic replacement and preserve unrelated keys; unreadable files are never treated as malformed JSON and overwritten. Malformed JSON can still be explicitly cleared or replaced. Avoid simultaneous configuration writes from multiple Pi processes: cross-process locking is not implemented.
+Global writes do not displace an existing project override. Config writes use same-directory atomic replacement and preserve unrelated keys; unreadable files are never treated as malformed JSON and overwritten. Malformed JSON must be manually repaired: set/clear commands will not replace or delete a corrupt shared file and risk resetting memory privacy controls. Avoid simultaneous configuration writes from multiple Pi processes: cross-process locking is not implemented.
 
 ---
 
@@ -226,6 +326,14 @@ The overlay header exposes three controls, all **off by default**:
 
 Long redirects are paged: review every page with Up/Down or PageUp/PageDown before pressing Y. Resize if the terminal is too small to review safely. Configured Pi selection keybindings are respected.
 
+### First-open neon intro
+
+The first `/jarvis` open for each main-session ID shows the ASCII wordmark with a **1.8-second cyan/violet/pink chrome sweep**. It is decorative, not a loading screen: startup and queued prompts continue normally, and the editor and permission controls remain usable. Type or paste to dismiss it immediately; your input is preserved. Escape still closes the overlay. Confirmation review and warnings/errors take priority.
+
+Reopening Jarvis, side `/new`, tree navigation, and returning to a previously opened main session do not replay it. The once-per-session memory lives in the loaded extension; restarting Pi or `/reload` resets it. Small terminals use a compact wordmark or skip the intro entirely. Light themes and 256-color terminals are supported; there is no flashing or terminal blinking.
+
+To skip the intro, start Pi with `PI_JARVIS_NO_ANIMATION=1`. A non-empty `NO_COLOR` or `TERM=dumb` also suppresses it. These switches affect the intro, not Pi's other animations or colors.
+
 ### Keyboard and drafts
 
 Version **1.5.0** adds compact diagnostics, scrollback, and a multiline draft editor.
@@ -246,7 +354,7 @@ The compact header keeps main status, the side model, main focus, and permission
 
 The multiline editor uses Pi's public editor and configured editing keybindings. Up/Down move within a draft; Up at the beginning of the first line (or in an empty editor) recalls prompts. Down past recalled prompts restores the draft. Pasted indentation and newlines are preserved, with Pi's normal tab-to-spaces normalization. Oversized drafts (over 64 KiB) and terminal-control payloads are rejected explicitly, never silently truncated or sent.
 
-Unsent drafts survive closing and reopening `/jarvis` in the same running Pi session. They are not saved to disk. Side `/new`, main-session replacement, and switching to an unrelated side-session reference clear them; navigating the side tree only resets the transcript view. Closing still revokes every permission.
+Unsent drafts survive closing and reopening `/jarvis` in the same running Pi session. They are not saved to disk. Side `/new`, main-session replacement, and switching to an unrelated side-session reference clear them; navigating the side tree only resets the transcript view. Closing still revokes all three overlay permissions; shared memory follows its separate persistent controls.
 
 Scrollback follows new output until you scroll up. To bound rendering work, the overlay retains up to 500 recent entries and 512K UTF-16 code units of source text, with a 64K-unit per-entry limit. Omitted content is marked explicitly; these display limits do not modify persisted conversation history. Resizing preserves the reading position on a best-effort basis.
 
@@ -398,6 +506,14 @@ Check the mandatory annotated **version-number** tag policy for committed histor
 npm run check:tags
 ```
 
+Regenerate the shared logo and actual-renderer demo artwork after visual changes:
+
+```bash
+npm run render:branding
+```
+
+This uses deterministic fixtures, without opening a terminal, calling a provider, or connecting to MCP servers.
+
 ### Release automation
 
 GitHub Actions validate branch pushes and pull requests on Node 22.19.0 and 24. They require an annotated **stable `vX.Y.Z` tag** on every reachable post-policy-baseline commit and run tests, build, and package verification. Every commit bumps the matching package and documentation versions; prerelease (`dev`, alpha, beta, RC), build-metadata, and SHA-only tags do not qualify. Fork PR jobs are read-only.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,YAAY,EAGjB,MAAM,iCAAiC,CAAC;AAkGzC,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAwhB9D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA,OAAO,EAEN,KAAK,YAAY,EAGjB,MAAM,iCAAiC,CAAC;AAqGzC,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CA4iB9D"}

package/dist/index.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { getAgentDir, } from "@earendil-works/pi-coding-agent";
 import { JarvisModelPicker } from "./model-picker.js";
 import { buildMainSessionContext } from "./main-context.js";
 import { MainSessionTracker } from "./main-session-state.js";
@@ -6,6 +7,8 @@ import { attachOverlayBridge, JarvisOverlayBridge, JarvisOverlayComponent } from
 import { createJarvisSessionRef, readJarvisSessionRef, JARVIS_SESSION_REF_CUSTOM_TYPE } from "./session-ref.js";
 import { MalformedJarvisConfigError, clearJarvisModelSelectionSetting, clearJarvisThinkingSelectionSetting, loadJarvisModelSelectionSetting, loadJarvisThinkingSelectionSetting, saveJarvisModelSelectionSetting, saveJarvisThinkingSelectionSetting, } from "./jarvis-config.js";
 import { JarvisSideSessionRuntime, createSideSessionFile } from "./side-session.js";
+import { SharedMemoryService } from "./memory-service.js";
+import { createMemoryExtensionFactory } from "./memory-extension.js";
 class StaleJarvisBootError extends Error {
     constructor() {
         super("/jarvis startup was superseded by a newer session lifecycle event.");
@@ -16,9 +19,13 @@ function isStaleJarvisBootError(error) {
     return error instanceof StaleJarvisBootError;
 }
 export default function jarvisExtension(pi) {
+    // Presentation-only memory, keyed by MAIN identity, never by the side tree.
+    // Reopening or returning to a session does not replay the intro.
+    const introSeenSessions = new Set();
     const mainSession = new MainSessionTracker();
     const state = {
         bridge: new JarvisOverlayBridge(),
+        memory: new SharedMemoryService(getAgentDir()),
         mainSession,
         mainContext: buildMainSessionContext(mainSession.snapshot()),
         lastJarvisSeenMainContext: undefined,
@@ -43,6 +50,11 @@ export default function jarvisExtension(pi) {
                 ctx.ui.notify("/jarvis requires Pi's interactive terminal UI.", "warning");
                 return;
             }
+            const memoryRequest = parseMemoryCommand(args);
+            if (memoryRequest !== undefined) {
+                dispatchMemoryCommand(state, memoryRequest, ctx, Boolean(state.overlayOpen));
+                return;
+            }
             if (state.overlayOpen) {
                 ctx.ui.notify("/jarvis is already open.", "info");
                 return;
@@ -75,7 +87,10 @@ export default function jarvisExtension(pi) {
                         queueMicrotask(() => tui.requestRender());
                     };
                     state.closeOverlay = closeOverlay;
-                    return attachOverlayBridge(new JarvisOverlayComponent(tui, theme, state.bridge, overlayView, closeOverlay, keybindings), state.bridge, tui);
+                    const sessionId = ctx.sessionManager.getSessionId();
+                    const component = attachOverlayBridge(new JarvisOverlayComponent(tui, theme, state.bridge, overlayView, closeOverlay, keybindings, { showIntro: !introSeenSessions.has(sessionId) }), state.bridge, tui);
+                    introSeenSessions.add(sessionId);
+                    return component;
                 }, {
                     overlay: true,
                     overlayOptions: {
@@ -314,6 +329,10 @@ export default function jarvisExtension(pi) {
             ctx.ui.notify(`Set /jarvis thinking to ${formatJarvisThinkingSelection(selection)} ${scopeLabel}. Effective /jarvis thinking is ${getDesiredJarvisThinkingLevel(state) ?? "off"}.`, "info");
         },
     });
+    pi.registerCommand("jarvis-memory", {
+        description: "Shared main Pi/Jarvis memory: status, on/off, capture/recall, search, remember, edit, forget (help for syntax)",
+        handler: async (args, ctx) => { dispatchMemoryCommand(state, args, ctx, false); },
+    });
     pi.on("session_start", async (_event, ctx) => {
         state.closeOverlay?.();
         state.bootGeneration += 1;
@@ -464,6 +483,7 @@ export default function jarvisExtension(pi) {
         // hang while the session is torn down.
         state.bridge.reset();
     });
+    createMemoryExtensionFactory(state.memory, "main")(pi);
 }
 function updateContextState(pi, state, ctx) {
     state.model = ctx.model;
@@ -829,6 +849,32 @@ function queueMessage(state, message) {
     state.queuedMessages.push(message);
     state.bridge.refresh();
 }
+function parseMemoryCommand(message) {
+    const match = /^\/(?:jarvis-memory|memory)(?:\s+([\s\S]*))?$/.exec(message.trim());
+    return match ? match[1] ?? "" : undefined;
+}
+function dispatchMemoryCommand(state, args, ctx, overlay) {
+    try {
+        const text = state.memory.command(args, ctx);
+        if (overlay && state.runtime)
+            state.runtime.addSystemMessage(text);
+        else if (overlay)
+            state.bridge.notify(text, "info");
+        else if (ctx.hasUI)
+            ctx.ui.notify(text, "info");
+        else
+            process.stderr.write(`${text}\n`);
+    }
+    catch (error) {
+        const text = error instanceof Error ? error.message : "Shared memory operation failed.";
+        if (overlay)
+            state.bridge.notify(text, "error");
+        else if (ctx.hasUI)
+            ctx.ui.notify(text, "error");
+        else
+            process.stderr.write(`${text}\n`);
+    }
+}
 function parseJarvisSideCommand(message) {
     const text = message.trim();
     if (text === "/new") {
@@ -907,6 +953,12 @@ function createOverlayView(pi, state, ctx) {
         sendMessage: async (text) => {
             if (state.queuedMessages !== queue)
                 return;
+            // Memory controls must work immediately, even while a side turn is busy.
+            const memoryCommand = parseMemoryCommand(text);
+            if (memoryCommand !== undefined) {
+                dispatchMemoryCommand(state, memoryCommand, ctx, true);
+                return;
+            }
             queueMessage(state, text);
             if (state.queuedMessages !== queue)
                 return;
@@ -1058,6 +1110,8 @@ async function ensureRuntime(pi, state, ctx) {
             bridge: state.bridge,
             cwd: ctx.cwd,
             projectTrusted: ctx.isProjectTrusted(),
+            memory: state.memory,
+            memoryTrustProvider: () => isCurrentBoot() && ctx.isProjectTrusted(),
             modelRegistry: ctx.modelRegistry,
             model: getDesiredJarvisModel(state),
             jarvisModelModeProvider: () => state.jarvisModelSelection.mode,