DevSync

Persistent engineering memory for Walrus Memory.

DevSync is a system prompt for a client that exposes memwal_recall and memwal_remember. It keeps three kinds of engineering context across chat sessions: failed approaches, settled decisions, and a concise handoff state.

Built for the Walrus Memory Prompt Jam.

What it does

A fresh chat often loses the reason an approach was rejected. DevSync stores that reason after a concrete failure and retrieves it when the same approach is proposed again.

Example:

1. A developer tries a BroadcastChannel heartbeat as session authority.
2. It fails on iOS Safari because background tabs throttle timers.
3. The prompt stores a pitfall with the root cause and an alternative.
4. In a fresh chat, the same proposal is recalled and explicitly blocked.

Memory layout

Each run uses a supplied scope. Records are isolated by namespace:

• pitfalls:<scope> — failed approach, observed failure, root cause, alternative
• decisions:<scope> — explicit technical decision and rationale
• taskstate:<scope> — task handoff: status, blocker, next action, files

The prompt never uses unscoped namespaces and excludes credentials, private keys, source code, stack traces, personal data, guesses, and temporary conversation text.

Prompt protocol

• On the first message in a chat, recall all three namespaces and do not write.
• On later messages, write only after a concrete failure, an explicit decision, or an explicit session end.
• Before a write, recall the target namespace and skip equivalent records.
• Treat a record as stored only after memwal_remember returns a confirmed blob_id.
• Block a proposal only when the matching scoped pitfall was actually recalled.

The complete prompt is in prompt.md.

Live demo

demo.py is a terminal demo using Groq function calling and the Python MemWal SDK.

Only user messages are predefined so the run can be recorded consistently. The model selects tool calls, namespaces, record text, and assistant responses. The script validates the scope, executes the selected calls, and writes demo_audit.json locally.

python3 -m pip install memwal httpx

export GROQ_API_KEY=...
export GROQ_API_KEY_2=...   # optional fallback
export GROQ_API_KEY_3=...   # optional fallback
export MEMWAL_ACCOUNT_ID=...
export MEMWAL_PRIVATE_KEY=...

# Two-session run: first-turn recall, failure storage, fresh-session recall
python3 demo.py --scope devsync-demo

# Add explicit decision and session-handoff turns
python3 demo.py --scope devsync-demo --full

# Validate a completed local audit manifest
python3 verify.py demo_audit.json

If a Groq key receives HTTP 429, the demo retries and then moves to the next configured fallback key. It does not fabricate a response, tool call, or blob receipt.

Verification

verify.py checks a completed manifest for:

• exact plaintext SHA-256 and UTF-8 byte count;
• valid blob IDs and matching Walruscan URLs;
• a successful Walruscan HTTP response;
• first-turn and recall-before-write protocol invariants in the recorded trace;
• fresh-session recall and explicit blocking;
• live MemWal recall of a confirmed blob.

Existing Mainnet records

The repository includes blob_write_results.json with 10 previously written Mainnet blob IDs. Each resolves on Walruscan:

Namespace	Count
pitfalls	4
decisions	4
taskstate	2
total	10

Open the links in blob_write_results.json or the list below:

• Pitfall: Safari ITP and localStorage
• Decision: session storage and httpOnly cookie
• Task state: in progress

Model checks

The v6 prompt was exercised with Groq function calling on llama-3.3-70b-versatile and llama-3.1-8b-instant.

• 70B follows the first-turn recall-only rule.
• The v6 first-turn section was added after 8B initially wrote task state too early; the revised prompt passed the targeted 8B test: recall-only on turn 1, pitfall storage after a concrete failure, and blocking in a fresh second session.
• A new full Mainnet run should use an unused scope and be verified with verify.py before being presented as submission evidence.

Repository contents

devsync/
├── prompt.md                 # system prompt
├── demo.py                   # Groq + Walrus Mainnet terminal demo
├── verify.py                 # audit verifier
├── blob_write_results.json   # IDs from prior Mainnet writes
├── PROBLEM.md                # problem statement
└── subtitles_ru.srt          # Russian subtitles