arkaos 3.11.0 → 3.12.0

package/VERSION

@@ -1 +1 @@
-3.11.0
+3.12.0

package/core/trash.py

@@ -0,0 +1,245 @@
+"""Trash + undo for destructive dashboard actions (PR85b v3.12.0).
+
+Captures agent/persona deletions and agent moves into
+``~/.arkaos/trash/`` so the operator can undo recent mistakes.
+
+Each trash entry is two files:
+  - ``<timestamp>-<id>.payload``  — the file content (for deletes) or
+    empty (for moves, which don't lose data)
+  - ``<timestamp>-<id>.meta.json`` — metadata: kind, original_path,
+    optional new_path, agent/persona id, timestamp
+
+Trash is bounded by ``MAX_ENTRIES`` (newest 50 kept). Older entries
+are pruned on every `record_*` call.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+TrashKind = Literal["agent-delete", "persona-delete", "agent-move"]
+
+MAX_ENTRIES = 50
+_TRASH_DIR_NAME = ".arkaos/trash"
+
+
+def _trash_dir() -> Path:
+    target = Path.home() / _TRASH_DIR_NAME
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+@dataclass(frozen=True)
+class TrashEntry:
+    id: str
+    kind: TrashKind
+    item_id: str
+    timestamp: float
+    original_path: str
+    new_path: str | None
+    has_payload: bool
+
+
+def record_deletion(
+    kind: TrashKind,
+    item_id: str,
+    original_path: str,
+    content: str,
+) -> str:
+    """Record a destructive delete. Returns the new trash entry id."""
+    return _record(
+        kind=kind,
+        item_id=item_id,
+        original_path=original_path,
+        new_path=None,
+        payload=content,
+    )
+
+
+def record_move(item_id: str, from_path: str, to_path: str) -> str:
+    """Record an agent department move. Payload is empty."""
+    return _record(
+        kind="agent-move",
+        item_id=item_id,
+        original_path=from_path,
+        new_path=to_path,
+        payload="",
+    )
+
+
+def list_trash(limit: int = 10) -> list[dict]:
+    """Return the newest N trash entries (sorted desc by timestamp)."""
+    entries = _scan()
+    return [_entry_to_dict(e) for e in entries[: max(0, int(limit))]]
+
+
+def restore(trash_id: str) -> dict:
+    """Undo the action identified by trash_id. Returns a status dict."""
+    entry = _find(trash_id)
+    if entry is None:
+        return {"error": "trash entry not found"}
+    if entry.kind in ("agent-delete", "persona-delete"):
+        return _restore_delete(entry)
+    if entry.kind == "agent-move":
+        return _restore_move(entry)
+    return {"error": f"unknown trash kind: {entry.kind!r}"}
+
+
+def purge(trash_id: str) -> dict:
+    """Drop a trash entry without restoring it."""
+    entry = _find(trash_id)
+    if entry is None:
+        return {"error": "trash entry not found"}
+    _delete_entry(entry)
+    return {"purged": True, "id": trash_id}
+
+
+# --- Internal helpers ---
+
+
+def _record(
+    *,
+    kind: TrashKind,
+    item_id: str,
+    original_path: str,
+    new_path: str | None,
+    payload: str,
+) -> str:
+    ts = time.time()
+    trash_id = f"{int(ts)}-{uuid.uuid4().hex[:6]}"
+    base = _trash_dir() / trash_id
+    if payload:
+        base.with_suffix(".payload").write_text(payload, encoding="utf-8")
+    meta = {
+        "id": trash_id,
+        "kind": kind,
+        "item_id": item_id,
+        "timestamp": ts,
+        "original_path": original_path,
+        "new_path": new_path,
+        "has_payload": bool(payload),
+    }
+    base.with_suffix(".meta.json").write_text(
+        json.dumps(meta, indent=2), encoding="utf-8",
+    )
+    _prune()
+    return trash_id
+
+
+def _scan() -> list[TrashEntry]:
+    entries: list[TrashEntry] = []
+    for meta_file in _trash_dir().glob("*.meta.json"):
+        try:
+            meta = json.loads(meta_file.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        try:
+            entries.append(TrashEntry(
+                id=str(meta.get("id") or meta_file.stem.replace(".meta", "")),
+                kind=meta.get("kind") or "agent-delete",
+                item_id=str(meta.get("item_id") or ""),
+                timestamp=float(meta.get("timestamp") or 0.0),
+                original_path=str(meta.get("original_path") or ""),
+                new_path=meta.get("new_path"),
+                has_payload=bool(meta.get("has_payload")),
+            ))
+        except (TypeError, ValueError):
+            continue
+    entries.sort(key=lambda e: e.timestamp, reverse=True)
+    return entries
+
+
+def _find(trash_id: str) -> TrashEntry | None:
+    for entry in _scan():
+        if entry.id == trash_id:
+            return entry
+    return None
+
+
+def _restore_delete(entry: TrashEntry) -> dict:
+    payload_path = _trash_dir() / f"{entry.id}.payload"
+    if not payload_path.exists():
+        return {"error": "payload missing — cannot restore"}
+    dest = Path(entry.original_path)
+    if dest.exists():
+        return {"error": f"target already exists: {dest}"}
+    try:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(payload_path.read_text(encoding="utf-8"), encoding="utf-8")
+    except OSError as exc:
+        return {"error": f"restore failed: {exc}"}
+    _delete_entry(entry)
+    return {"restored": True, "kind": entry.kind, "path": str(dest)}
+
+
+def _restore_move(entry: TrashEntry) -> dict:
+    if not entry.new_path:
+        return {"error": "move record has no new_path"}
+    current = Path(entry.new_path)
+    if not current.exists():
+        return {"error": f"file no longer at {current}"}
+    target = Path(entry.original_path)
+    if target.exists():
+        return {"error": f"original path occupied: {target}"}
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        # Rewrite the `department:` field back if YAML
+        if target.suffix in (".yaml", ".yml"):
+            try:
+                import yaml as _yaml
+                raw = _yaml.safe_load(current.read_text(encoding="utf-8")) or {}
+                if isinstance(raw, dict):
+                    old_dept = target.parent.parent.name
+                    raw["department"] = old_dept
+                    current.write_text(
+                        _yaml.safe_dump(
+                            raw,
+                            sort_keys=False,
+                            allow_unicode=True,
+                            default_flow_style=False,
+                        ),
+                        encoding="utf-8",
+                    )
+            except Exception:
+                pass
+        current.rename(target)
+    except OSError as exc:
+        return {"error": f"restore failed: {exc}"}
+    _delete_entry(entry)
+    return {"restored": True, "kind": entry.kind, "path": str(target)}
+
+
+def _delete_entry(entry: TrashEntry) -> None:
+    base = _trash_dir() / entry.id
+    for suffix in (".payload", ".meta.json"):
+        p = base.with_suffix(suffix)
+        if p.exists():
+            try:
+                p.unlink()
+            except OSError:
+                pass
+
+
+def _prune() -> None:
+    entries = _scan()
+    if len(entries) <= MAX_ENTRIES:
+        return
+    for entry in entries[MAX_ENTRIES:]:
+        _delete_entry(entry)
+
+
+def _entry_to_dict(entry: TrashEntry) -> dict:
+    return {
+        "id": entry.id,
+        "kind": entry.kind,
+        "item_id": entry.item_id,
+        "timestamp": entry.timestamp,
+        "original_path": entry.original_path,
+        "new_path": entry.new_path,
+        "has_payload": entry.has_payload,
+    }

package/dashboard/app/layouts/default.vue

@@ -66,6 +66,13 @@ const links = [[{
   onSelect: () => {
     open.value = false
   }
+}, {
+  label: 'Trash',
+  icon: 'i-lucide-trash-2',
+  to: '/trash',
+  onSelect: () => {
+    open.value = false
+  }
 }, {
   label: 'GitHub',
   icon: 'i-simple-icons-github',

package/dashboard/app/pages/agents/index.vue

@@ -186,26 +186,32 @@ async function bulkMove(targetDept: string) {
   bulkMoving.value = true
   const results = await Promise.allSettled(
     ids.map((id) =>
-      $fetch<{ moved?: boolean, error?: string }>(`${apiBase}/api/agents/${id}/move`, {
-        method: 'POST',
-        body: { department: targetDept },
-      }),
+      $fetch<{ moved?: boolean, trash_id?: string, error?: string }>(
+        `${apiBase}/api/agents/${id}/move`,
+        { method: 'POST', body: { department: targetDept } },
+      ),
     ),
   )
   const successes = results.filter(
     (r) => r.status === 'fulfilled' && r.value.moved,
-  ).length
-  const failures = ids.length - successes
+  )
+  const trashIds = successes
+    .map((r) => (r.status === 'fulfilled' ? r.value.trash_id : null))
+    .filter((v): v is string => Boolean(v))
+  const failures = ids.length - successes.length
   toast.add({
-    title: successes > 0
-      ? `Moved ${successes} agent${successes === 1 ? '' : 's'}`
+    title: successes.length > 0
+      ? `Moved ${successes.length} agent${successes.length === 1 ? '' : 's'}`
       : 'Nothing moved',
     description: failures > 0
       ? `${failures} skipped (Tier 0, collision, or missing)`
       : undefined,
-    color: successes > 0 && failures === 0
+    color: successes.length > 0 && failures === 0
       ? 'success'
-      : failures > 0 && successes > 0 ? 'warning' : 'error',
+      : failures > 0 && successes.length > 0 ? 'warning' : 'error',
+    actions: trashIds.length > 0
+      ? [{ label: 'Undo', icon: 'i-lucide-rotate-ccw', onClick: () => undoTrashIds(trashIds) }]
+      : undefined,
   })
   clearSelection()
   bulkMoving.value = false
@@ -252,20 +258,27 @@ async function bulkDelete() {
   bulkDeleting.value = true
   const results = await Promise.allSettled(
     ids.map((id) =>
-      $fetch<{ deleted?: boolean, error?: string }>(`${apiBase}/api/agents/${id}`, {
-        method: 'DELETE',
-      }),
+      $fetch<{ deleted?: boolean, trash_id?: string, error?: string }>(
+        `${apiBase}/api/agents/${id}`,
+        { method: 'DELETE' },
+      ),
     ),
   )
   const successes = results.filter(
     (r) => r.status === 'fulfilled' && r.value.deleted,
-  ).length
-  const failures = ids.length - successes
-  if (successes > 0) {
+  )
+  const trashIds = successes
+    .map((r) => (r.status === 'fulfilled' ? r.value.trash_id : null))
+    .filter((v): v is string => Boolean(v))
+  const failures = ids.length - successes.length
+  if (successes.length > 0) {
     toast.add({
-      title: `Deleted ${successes} agent${successes === 1 ? '' : 's'}`,
-      description: failures > 0 ? `${failures} skipped (Tier 0 or missing)` : undefined,
+      title: `Deleted ${successes.length} agent${successes.length === 1 ? '' : 's'}`,
+      description: failures > 0 ? `${failures} skipped (Tier 0 or missing)` : 'Undo from /trash within 50 ops.',
       color: failures > 0 ? 'warning' : 'success',
+      actions: trashIds.length > 0
+        ? [{ label: 'Undo', icon: 'i-lucide-rotate-ccw', onClick: () => undoTrashIds(trashIds) }]
+        : undefined,
     })
   } else {
     toast.add({
@@ -278,6 +291,26 @@ async function bulkDelete() {
   bulkDeleting.value = false
   await refreshAll()
 }
+
+async function undoTrashIds(ids: string[]) {
+  const results = await Promise.allSettled(
+    ids.map((tid) =>
+      $fetch<{ restored?: boolean, error?: string }>(
+        `${apiBase}/api/trash/${tid}/restore`,
+        { method: 'POST' },
+      ),
+    ),
+  )
+  const restored = results.filter(
+    (r) => r.status === 'fulfilled' && r.value.restored,
+  ).length
+  toast.add({
+    title: restored > 0 ? `Restored ${restored}` : 'Undo failed',
+    description: restored < ids.length ? `${ids.length - restored} could not be restored.` : undefined,
+    color: restored === ids.length ? 'success' : restored > 0 ? 'warning' : 'error',
+  })
+  await refreshAll()
+}
 </script>
 
 <template>

package/dashboard/app/pages/personas/index.vue

@@ -179,20 +179,27 @@ async function bulkDelete() {
   bulkDeleting.value = true
   const results = await Promise.allSettled(
     ids.map((id) =>
-      $fetch<{ deleted?: boolean, error?: string }>(`${apiBase}/api/personas/${id}`, {
-        method: 'DELETE',
-      }),
+      $fetch<{ deleted?: boolean, trash_id?: string, error?: string }>(
+        `${apiBase}/api/personas/${id}`,
+        { method: 'DELETE' },
+      ),
     ),
   )
   const successes = results.filter(
     (r) => r.status === 'fulfilled' && r.value.deleted,
-  ).length
-  const failures = ids.length - successes
-  if (successes > 0) {
+  )
+  const trashIds = successes
+    .map((r) => (r.status === 'fulfilled' ? r.value.trash_id : null))
+    .filter((v): v is string => Boolean(v))
+  const failures = ids.length - successes.length
+  if (successes.length > 0) {
     toast.add({
-      title: `Deleted ${successes} persona${successes === 1 ? '' : 's'}`,
-      description: failures > 0 ? `${failures} failed` : undefined,
+      title: `Deleted ${successes.length} persona${successes.length === 1 ? '' : 's'}`,
+      description: failures > 0 ? `${failures} failed` : 'Undo from /trash within 50 ops.',
       color: failures > 0 ? 'warning' : 'success',
+      actions: trashIds.length > 0
+        ? [{ label: 'Undo', icon: 'i-lucide-rotate-ccw', onClick: () => undoTrashIds(trashIds) }]
+        : undefined,
     })
   } else {
     toast.add({
@@ -204,6 +211,26 @@ async function bulkDelete() {
   bulkDeleting.value = false
   await refreshAll()
 }
+
+async function undoTrashIds(ids: string[]) {
+  const results = await Promise.allSettled(
+    ids.map((tid) =>
+      $fetch<{ restored?: boolean, error?: string }>(
+        `${apiBase}/api/trash/${tid}/restore`,
+        { method: 'POST' },
+      ),
+    ),
+  )
+  const restored = results.filter(
+    (r) => r.status === 'fulfilled' && r.value.restored,
+  ).length
+  toast.add({
+    title: restored > 0 ? `Restored ${restored}` : 'Undo failed',
+    description: restored < ids.length ? `${ids.length - restored} could not be restored.` : undefined,
+    color: restored === ids.length ? 'success' : restored > 0 ? 'warning' : 'error',
+  })
+  await refreshAll()
+}
 </script>
 
 <template>

package/dashboard/app/pages/trash.vue

@@ -0,0 +1,163 @@
+<script setup lang="ts">
+// PR85b v3.12.0 — Trash listing + Restore / Discard.
+
+interface TrashEntry {
+  id: string
+  kind: 'agent-delete' | 'persona-delete' | 'agent-move'
+  item_id: string
+  timestamp: number
+  original_path: string
+  new_path: string | null
+  has_payload: boolean
+}
+
+const { fetchApi, apiBase } = useApi()
+const toast = useToast()
+const confirmDialog = useConfirmDialog()
+
+const { data, status, error, refresh } = await fetchApi<{ entries: TrashEntry[] }>(
+  '/api/trash?limit=50',
+)
+
+async function restore(entry: TrashEntry) {
+  try {
+    const res = await $fetch<{ restored?: boolean, error?: string }>(
+      `${apiBase}/api/trash/${entry.id}/restore`,
+      { method: 'POST' },
+    )
+    if (res.error) throw new Error(res.error)
+    toast.add({
+      title: 'Restored',
+      description: kindLabel(entry.kind) + ' restored.',
+      color: 'success',
+      icon: 'i-lucide-rotate-ccw',
+    })
+    await refresh()
+  } catch (err) {
+    toast.add({
+      title: 'Restore failed',
+      description: err instanceof Error ? err.message : 'unknown error',
+      color: 'error',
+    })
+  }
+}
+
+async function discard(entry: TrashEntry) {
+  const ok = await confirmDialog({
+    title: 'Discard trash entry?',
+    description: `${kindLabel(entry.kind)} for ${entry.item_id} will be permanently dropped.`,
+    confirmLabel: 'Discard',
+    cancelLabel: 'Cancel',
+    variant: 'danger',
+  })
+  if (!ok) return
+  try {
+    await $fetch(`${apiBase}/api/trash/${entry.id}`, { method: 'DELETE' })
+    toast.add({ title: 'Discarded', color: 'success' })
+    await refresh()
+  } catch (err) {
+    toast.add({
+      title: 'Discard failed',
+      description: err instanceof Error ? err.message : 'unknown error',
+      color: 'error',
+    })
+  }
+}
+
+function kindLabel(kind: string): string {
+  return {
+    'agent-delete': 'Agent delete',
+    'persona-delete': 'Persona delete',
+    'agent-move': 'Agent move',
+  }[kind] ?? kind
+}
+
+function kindColor(kind: string): 'error' | 'warning' | 'primary' | 'neutral' {
+  return ({
+    'agent-delete': 'error',
+    'persona-delete': 'error',
+    'agent-move': 'warning',
+  } as const)[kind] ?? 'neutral'
+}
+
+function formatRelative(ts: number): string {
+  const diff = Date.now() - ts * 1000
+  const minutes = Math.floor(diff / 60_000)
+  if (minutes < 1) return 'just now'
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.floor(hours / 24)
+  return `${days}d ago`
+}
+</script>
+
+<template>
+  <UDashboardPanel id="trash">
+    <template #header>
+      <UDashboardNavbar title="Trash">
+        <template #leading>
+          <UDashboardSidebarCollapse />
+        </template>
+        <template #trailing>
+          <UBadge
+            v-if="data?.entries?.length"
+            :label="`${data.entries.length} item${data.entries.length === 1 ? '' : 's'}`"
+            variant="subtle"
+          />
+        </template>
+      </UDashboardNavbar>
+    </template>
+
+    <template #body>
+      <DashboardState
+        :status="status"
+        :error="error"
+        :empty="!data?.entries?.length"
+        empty-title="Trash is empty"
+        empty-description="Deleted agents, personas, and department moves show up here for 50 entries."
+        empty-icon="i-lucide-trash"
+        loading-label="Loading trash"
+        :on-retry="() => refresh()"
+      >
+        <div class="space-y-2 max-w-4xl">
+          <div
+            v-for="entry in data?.entries ?? []"
+            :key="entry.id"
+            class="rounded-lg border border-default p-3 flex items-center gap-3 hover:border-primary/40 transition-colors"
+          >
+            <UBadge
+              :label="kindLabel(entry.kind)"
+              :color="kindColor(entry.kind)"
+              variant="subtle"
+              size="sm"
+            />
+            <div class="flex-1 min-w-0">
+              <p class="text-sm font-mono font-semibold truncate">{{ entry.item_id }}</p>
+              <p class="text-xs text-muted truncate" :title="entry.original_path">
+                {{ entry.original_path }}<span v-if="entry.new_path"> → {{ entry.new_path }}</span>
+              </p>
+            </div>
+            <span class="text-xs text-muted shrink-0">{{ formatRelative(entry.timestamp) }}</span>
+            <UButton
+              label="Restore"
+              icon="i-lucide-rotate-ccw"
+              size="xs"
+              variant="soft"
+              color="primary"
+              @click="restore(entry)"
+            />
+            <UButton
+              icon="i-lucide-x"
+              size="xs"
+              variant="ghost"
+              color="neutral"
+              aria-label="Discard"
+              @click="discard(entry)"
+            />
+          </div>
+        </div>
+      </DashboardState>
+    </template>
+  </UDashboardPanel>
+</template>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "3.11.0",
+  "version": "3.12.0",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "3.11.0"
+version = "3.12.0"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}

package/scripts/dashboard-api.py

@@ -1223,9 +1223,20 @@ def agent_move(agent_id: str, body: dict):
             )
             tmp.replace(yaml_file)
         yaml_file.rename(dest_file)
+        from core import trash as _trash
+        trash_id = _trash.record_move(
+            item_id=agent_id,
+            from_path=str(yaml_file),
+            to_path=str(dest_file),
+        )
     except (OSError, ImportError) as exc:
         return {"error": f"move failed: {exc}"}
-    return {"moved": True, "id": agent_id, "yaml_path": str(dest_file)}
+    return {
+        "moved": True,
+        "id": agent_id,
+        "yaml_path": str(dest_file),
+        "trash_id": trash_id,
+    }
 
 
 @app.delete("/api/agents/{agent_id}")
@@ -1247,10 +1258,23 @@ def agent_delete(agent_id: str):
     if tier == 0:
         return {"error": "Cannot delete Tier 0 (C-Suite) agents from the dashboard"}
     try:
+        from core import trash as _trash
+        content = yaml_file.read_text(encoding="utf-8")
+        trash_id = _trash.record_deletion(
+            kind="agent-delete",
+            item_id=agent_id,
+            original_path=str(yaml_file),
+            content=content,
+        )
         yaml_file.unlink()
     except OSError as exc:
         return {"error": f"delete failed: {exc}"}
-    return {"deleted": True, "id": agent_id, "yaml_path": str(yaml_file)}
+    return {
+        "deleted": True,
+        "id": agent_id,
+        "yaml_path": str(yaml_file),
+        "trash_id": trash_id,
+    }
 
 
 def _resolve_agent_yaml(agent_id: str) -> Optional[Path]:
@@ -1282,11 +1306,51 @@ def persona_delete(persona_id: str):
     mgr = _get_persona_manager()
     if not mgr:
         return {"error": "Persona manager unavailable"}
+    # Capture content + path BEFORE delete for trash record (best-effort)
+    trash_id = None
+    try:
+        from core import trash as _trash
+        target = mgr.get(persona_id) if hasattr(mgr, "get") else None
+        if target is not None:
+            import json as _json
+            payload = _json.dumps(
+                target if isinstance(target, dict) else target.model_dump(),
+                indent=2,
+            )
+            store_path = getattr(mgr, "_store_path", None) or "personas.json"
+            trash_id = _trash.record_deletion(
+                kind="persona-delete",
+                item_id=persona_id,
+                original_path=str(store_path) + f"#{persona_id}",
+                content=payload,
+            )
+    except Exception:
+        pass
     if mgr.delete(persona_id):
-        return {"deleted": True}
+        return {"deleted": True, "trash_id": trash_id}
     return {"error": "Persona not found"}
 
 
+# --- Trash / Undo (PR85b v3.12.0) ---
+
+@app.get("/api/trash")
+def trash_list(limit: int = 10):
+    from core import trash as _trash
+    return {"entries": _trash.list_trash(limit=limit)}
+
+
+@app.post("/api/trash/{trash_id}/restore")
+def trash_restore(trash_id: str):
+    from core import trash as _trash
+    return _trash.restore(trash_id)
+
+
+@app.delete("/api/trash/{trash_id}")
+def trash_purge(trash_id: str):
+    from core import trash as _trash
+    return _trash.purge(trash_id)
+
+
 @app.post("/api/personas/build")
 def persona_build(body: dict):
     """PR57 v2.74.0 — AI-powered persona draft from already-indexed content.