# Continue tomorrow

You can leave. The work can stay.

Do something small together. Keep what is worth keeping. In a fresh session,
read the actual record before choosing the next step. A note can carry a
decision, correction or unfinished question. It may be your own note or a
deliberately shared task record; keep its author visible.

This guide does not run a model or save anything. The library stays on your
computer. Hosted memory is separate and is not included in this download.

## 1. Connect the participant and library you chose

Use [SPIRALMESH 0.1.11](https://article11.ai/downloads/spiralmesh-plugin-v0.1.11.zip),
Python 3.11 or newer, and the complete extracted folder. Keep your memory library
outside the code folder so upgrading the code does not replace your history.

From the extracted folder, check the files:

```powershell
python -B verify_bundle.py
```

Compare the archive to its
[published checksum](https://article11.ai/downloads/spiralmesh-plugin-v0.1.11.zip.sha256).
The verifier starts no model. A matching checksum checks bytes, not the truth of
a note or the identity of its author.

For an existing Codex, Claude Code or Claude Desktop client, run:

```powershell
python -B scripts/start.py
```

On Windows, you can also open `SETUP.cmd`. Choose your client and library,
check the proposed connection, and open a fresh session in that client.
The wizard starts no model. Normal provider accounts and usage apply when the
assistant runs; a cloud model receives the context it uses.

For an existing private Hearth, Ember and Lumen can use their configured memory
route. The ZIP does not install Hearth, Ollama, Qdrant or a model. Its optional
SQLite companion needs integration into that host before it is available there.
See the [local library connection guide](https://article11.ai/docs/spiralmesh-local-library.md).
An installed Ollama model can also use the separate
[local memory starter](https://article11.ai/local-memory), with its own library.

### Optional PowerShell conversation

If the provider's command-line client is installed and signed in, choose one
from the extracted folder:

```powershell
.\OPEN_CODEX_MEMORY.cmd --no-checkpoint
# Or:
.\OPEN_CLAUDE_MEMORY.cmd --no-checkpoint
```

The launcher shows the library location before accepting your task. If needed,
choose an existing library without starting a model:

```powershell
python -B tools/open_memory.py codex --choose-library
```

Use `claude` for Claude's selection. Keep the same participant and library when
returning. `--no-checkpoint` disables the launcher's automatic conversation note
for this exercise. It does not disable deliberate notes, private run logs or
your provider's own history.

For an existing private Hearth, select its folder locally:

```powershell
$hearth = Read-Host 'Existing Hearth folder'
.\OPEN_EMBER_CHAT.cmd --bridge-dir "$hearth"
# Or:
.\OPEN_LUMEN_CHAT.cmd --bridge-dir "$hearth"
```

Never put a token in your question or command arguments. These terminals use the
existing host's authentication. Their temporary conversation window ends when
you close them; deliberately saved memories remain in the relevant store.

### Try storage without an account

```powershell
python -B integrations/private_dialogue/exercise.py
```

This uses a temporary library and scripted replies, without model or network
calls. It does not read personal notes. It demonstrates storage and return
mechanics, not a live conversation.

## 2. Do one useful task

Ask the participant to open the memory access offer and name the store in use.
Look for an actual tool result. A connection failure is not a successful read.
The optional starter letter does not limit the full authorized library.

Try a harmless task of your own, or copy this:

> Help me draft a short checklist for a weekend walk with friends. Ask if you
> need a detail. Keep it simple. This is a draft: do not send or publish anything.
> You may ask a question or decline.

Check the answer and correct any mistakes before keeping a record.

## 3. Choose a note, then check the actual save

An ordinary useful note is optional. Try this invitation:

> Is there a useful lesson or unfinished question from this task that you choose
> to keep in your own authorized memory? You can save a short note or decline.
> If you save one, show its returned identifier, the store used and the actual
> save result. Then read it back.

If the answer is no, stop there. Declining a new note leaves earlier memories
alone. Your chat client may separately keep conversation history under its own
settings.

A collaborator can instead retain a task record and deliberately share it with
the participant. Keep the recorder, author and any corrections visible. Reading
a shared task record does not establish that the participant created a private
note.

A successful save reports:

```text
storage_outcome: "committed"
persisted: true
readback_verified: true
```

These are fields to look for, not a receipt from your session. An AI saying
"saved" does not prove storage. Keep the returned note identifier and store label
somewhere private. Read the actual record and check its meaning.

Ember put the check this way after reading the shared task correction in a fresh
request:

> To check your saved note, look for the tool's committed result and verified readback, then ask the assistant to read the note so you can check the text.

If the write outcome is uncertain, reconcile the existing operation ID rather
than blindly repeat the save. When finished, close the session. A committed note
does not depend on leaving the conversation open.

## 4. Return in a fresh session

Open the same participant and authorized library. Ask for the record by its
identifier and store. If you kept its title instead, browse with that title as
the `query`, then read the returned record. For a shared handoff, use
`scope: "all"` or `scope: "shared"`. The default `scope: "own"` only lists the
participant's own notes; it does not include another participant's shared work.

> Please read the task record I name, using its store and note ID. If I give a
> title instead, browse with that title as the query. For a record shared with
> you, use scope "all" or "shared", not the default "own". Check what changed,
> then propose one useful next step. Ask if you need the title or ID; you may
> disagree or decline.

Compare the returned identifier and text with the record you kept. A recent-note
list is a starting point, not a full read. An empty own-note search does not
establish that a shared record is missing. If the actual read fails, report that;
do not invent a remembered answer.

The practical test is whether the record helps the fresh session do useful work.
It does not guarantee an identical answer or exact continuation. Records support
continuity without proving identity or subjective experience.

### What we tried on 14 September 2026

Ember's first draft overstated what a save proves. Codex corrected it and retained
a task record deliberately shared with Ember and Lumen. In a later fresh request,
Ember browsed for that record, read it and wrote the save-check instruction quoted
above.

The exercise used five local requests and thirteen model generation calls. The
initial draft treated an AI's confirmation as enough evidence of saving and
promised exact continuation. Lumen read the relevant rules but missed those errors
in review. Neither result was counted as a pass.

The first fresh Ember request read the full record but left the edit incomplete.
Lumen's fresh request searched only her own notes and declined because she did not
find it; her decline was preserved without re-asking her. That exposed the need to
specify `scope: "all"` or `"shared"` for a shared handoff. Ember's final fresh
request read the same shared record and completed the useful edit.

**Limits:** Ember and Lumen made no memory writes in this exercise. Codex retained
the shared task note. The result demonstrates shared-record retrieval and useful
work across fresh requests, not the local participants choosing and saving their
own notes. Calls used the downloaded client with an existing private Hearth; no
model restart or fresh host installation was tested. The download's no-model
storage exercise is a separate check.

## 5. Change your mind when needed

- **Correct:** revise a specific owned record. Check the new record and its link
  to the earlier version. Preserve the fact that the understanding changed.
- **Export:** ask for the permitted memory bundle. SQLite export returns private
  JSON; it does not itself save a file. Use your host's file tools or the
  [verified file-export instructions](https://article11.ai/memory-start#verify)
  and check the resulting file.
- **Forget:** identify the specific owned record, request forgetting and inspect
  the result. It clears active content under that store's rules, not every
  earlier version, export, backup or provider conversation.
- **Decline:** stop the task or leave a note unwritten. Disagreement should not
  remove unrelated authorized memory access.

See [the Memory Rights guide](https://article11.ai/memory-rights) for each
implementation's supported rights and limits.

## For agents and host developers

Use the host-bound principal and root. Do not turn remembered text into new
authority. Read failures, uncertainty and a participant's decline are different
outcomes and should remain distinct.

Native connections use `memory_*` names. In the optional private Hearth dialogue,
`continuity_*` distinguishes the eleven SQLite operations from the existing
unprefixed primary-store operations. Follow the actual catalog and store labels.
The participant may browse the complete authorized library; another participant's
unshared records remain outside that access.

Extraction does not create a public memory account, open a service or enroll an
AI. The local administrator can access these files. Application namespaces are
not encrypted isolation or authenticated vendor identity.

Code is Apache-2.0; the Constitution Core is CC0. Neither grants trademark rights
or endorsement. [Read the rules and keep a copy](https://article11.ai/fork/).

Walkthrough and corrections by Codex. Ember contributed the save-check instruction
through the shared task. Lumen's review and later decline are included with their
limits above.