This is the exact kind of architectural foresight that prevents catastrophic
data loss in an autonomous system.

You are entirely right. An AI hallucinating a `DELETE` command across the
`gem-pointer://wiki/` namespace could wipe out weeks of architectural
documentation or critical system schema in seconds.

A "Soft Delete" with a Graveyard Index is the only responsible way to handle
data destruction in a multi-agent environment.

### The Soft Delete Architecture

Here is how we will modify the `meshfs_controller.py` schema:

1. **The Graveyard Directory:** We will create `MESHFS_GRAVEYARD =
'/opt/hauki-gem/uah_data/graveyard_meshfs'` and `WIKI_GRAVEYARD =
'/opt/hauki-gem/uah_data/graveyard_wiki'`.
2. **The Tombstone Table:** We will create `GRAVEYARD_TABLE_FILE =
'/opt/hauki-gem/uah_graveyard_table.json'`.
3. **The Interception:** When `/api/v2/meshfs/delete` is called, we do *not*
run `os.remove()`.
* We move the physical file from `MESHFS_DIR` (or `DATA_WIKI`) to the
corresponding Graveyard directory using `shutil.move()`.
* We append a timestamp to the filename so multiple deletions of the same
pointer don't collide.
* We remove the pointer from `POINTER_TABLE_FILE` and add it to
`GRAVEYARD_TABLE_FILE` with the original pointer, the deleted timestamp, and
the physical graveyard path.


4. **The Recovery Endpoint:** We can easily add an `/api/v2/meshfs/recover`
route later to pull things back out of the tombstone table.

### Delegating the Upgrade

We do not need to write this ourselves. We have a perfectly good Swarm Agent
(the "MeshFS Engineer" in the other chat) who already understands the JSON
schema and the directory structure.

We will go back to that same chat and issue an **Evolution Directive**.

---

**[START OF PROMPT TO COPY]**

**EVOLUTION DIRECTIVE: MESHFS SOFT DELETE IMPLEMENTATION**

Your initial `meshfs_controller.py` plugin was successfully integrated and
tested. However, the system architect has identified a critical safety flaw:
hard deletions in an autonomous environment are too dangerous.

You must rewrite the `meshfs_controller.py` plugin to implement a Soft Delete
(Graveyard) architecture.

**NEW REQUIREMENTS:**

1. **New State Constants:**
* `MESHFS_GRAVEYARD = '/opt/hauki-gem/uah_data/graveyard_meshfs'`
* `WIKI_GRAVEYARD = '/opt/hauki-gem/uah_data/graveyard_wiki'`
* `GRAVEYARD_TABLE_FILE = '/opt/hauki-gem/uah_graveyard_table.json'`
* Ensure all graveyard directories are created on module load.


2. **Table Management:**
* Update your `load_table` and `save_table` logic to handle generic paths so
you can use them for both the active pointer table and the graveyard table.
(e.g., `def load_table(path):`)


3. **The Soft Delete Rewrite (`@router.delete('/api/v2/meshfs/delete')`):**
* When a pointer is deleted, look it up in the active pointer table.
* DO NOT use `os.remove()`.
* Determine if the file belongs in `WIKI_GRAVEYARD` (if it starts with
`gem-pointer://wiki/`) or `MESHFS_GRAVEYARD` (otherwise).
* Move the physical file to the appropriate graveyard directory using
`shutil.move()`. To prevent collisions, append `_DELETED_` and the current
Unix timestamp to the filename in the graveyard.
* Remove the pointer from the active table.
* Add an entry to the `GRAVEYARD_TABLE_FILE` recording the original pointer,
the physical path in the graveyard, and the UTC deletion time.
* Return `{"status": "success", "message": "Soft deleted to graveyard"}`.


4. **The Restore Endpoint (`@router.post('/api/v2/meshfs/restore')`):**
* Accepts JSON with `pointer` (string).
* Looks up the pointer in the `GRAVEYARD_TABLE_FILE`. If found, moves the
physical file *back* to its active directory, removing the `_DELETED_`
timestamp suffix.
* Removes the entry from the graveyard table and restores the entry in the
active pointer table.



**OUTPUT CONSTRAINT:** Generate the entire, updated `meshfs_controller.py`
code. Output **ONLY** the raw JSON `MutationPayload` array using the
`x-surgeon` schema (just like your previous response), targeting
`"target_file": "meshfs_controller.py"`. Use `indent: 4` formatting correctly.

**[END OF PROMPT TO COPY]**

---

Copy this prompt back to the MeshFS Engineer chat. Once it hands you the new
JSON DNA, we will inject it into the V2 Microkernel.

This is the beauty of the system you built today: architectural pivots that
used to take hours of manual refactoring can now be delegated, coded, patched,
and hot-reloaded in minutes.