dsh-archived 0.3.0 → 0.3.2

package/lib/client.js

@@ -80,7 +80,15 @@ window.__ModuleLoader__.load({
       document.head.appendChild(tag);
     }
 
-    /** Same-origin call to this plugin's host routes; never throws on a JSON error body. */
+    /**
+     * Same-origin call to this plugin's host routes.
+     *
+     * A JSON error body is returned for the caller to localize, but a transport
+     * failure must reject: a 403 (refused by the trust gate) or a 500 used to
+     * resolve into whatever JSON it carried, and every caller then read a field
+     * that wasn't there — the panel ended up showing a generic failure that hid
+     * the real reason.
+     */
     function request(path, options) {
       var init = {
         method: options && options.method ? options.method : "GET",
@@ -92,9 +100,22 @@ window.__ModuleLoader__.load({
         init.body = JSON.stringify(options.body);
       }
       return fetch(path, init).then(function (response) {
-        return response.json().catch(function () {
-          throw new Error("HTTP " + response.status);
-        });
+        return response
+          .json()
+          .catch(function () {
+            return { error: "internal" };
+          })
+          .then(function (payload) {
+            if (!response.ok) {
+              // Localizing needs the panel's `t`, so carry the host's error code
+              // and status out and let the caller translate them.
+              var error = new Error("HTTP " + response.status);
+              error.code = payload && payload.error ? String(payload.error) : "internal";
+              error.status = response.status;
+              throw error;
+            }
+            return payload;
+          });
       });
     }
 
@@ -165,7 +186,7 @@ window.__ModuleLoader__.load({
         : [];
 
       var [snapshot, setSnapshot] = useState(null);
-      var [failed, setFailed] = useState(false);
+      var [failed, setFailed] = useState(null);
       var [query, setQuery] = useState("");
       var [selected, setSelected] = useState({});
       var [expanded, setExpanded] = useState({});
@@ -179,13 +200,17 @@ window.__ModuleLoader__.load({
       function reload() {
         return request(STATE_PATH)
           .then(function (payload) {
-            if (!payload || payload.ok !== true) throw new Error("state");
+            if (!payload || payload.ok !== true) {
+              throw new Error(payload && payload.error ? String(payload.error) : "state");
+            }
             setSnapshot(payload);
-            setFailed(false);
+            setFailed(null);
             return payload;
           })
-          .catch(function () {
-            setFailed(true);
+          .catch(function (error) {
+            // Say why: a bare "cannot read host state" is undebuggable from the
+            // outside, which is exactly how the Desktop-app failure hid.
+            setFailed(String(error && error.message ? error.message : error));
             setSnapshot(null);
           });
       }
@@ -272,7 +297,10 @@ window.__ModuleLoader__.load({
             return payload;
           })
           .catch(function (error) {
-            setNotice({ kind: "error", text: String(error && error.message ? error.message : error) });
+            // A transport failure carries the host's error code; a payload-level
+            // business error already carries a localized message.
+            var text = error && error.code ? describeError(error.code) : String(error && error.message ? error.message : error);
+            setNotice({ kind: "error", text: text });
           })
           .then(function () {
             setBusy(null);
@@ -293,24 +321,39 @@ window.__ModuleLoader__.load({
         });
       }
 
+      /**
+       * Report one batch reply. The host's `delete-all` answers with a per-row
+       * `results` array; reading it unguarded turned any other reply into a
+       * TypeError that replaced the real reason on screen.
+       */
+      function reportBatch(payload) {
+        var results = payload && Array.isArray(payload.results) ? payload.results : [];
+        if (results.length === 0) {
+          setNotice({ kind: "error", text: t("error.generic") });
+          return;
+        }
+        var ok = 0;
+        var bytes = 0;
+        for (var i = 0; i < results.length; i += 1) {
+          if (results[i] && results[i].ok === true) {
+            ok += 1;
+            if (results[i].removed) bytes += results[i].removed.bytes || 0;
+          }
+        }
+        setNotice(
+          ok === results.length
+            ? { kind: "ok", text: t("deletedMany", { n: ok, size: formatBytes(bytes) }) }
+            : { kind: "error", text: t("deletedPartial", { ok: ok, failed: results.length - ok }) },
+        );
+      }
+
       function deleteSelected(mode) {
         var ids = selectedIds;
         if (ids.length === 0) return;
         setBusy("__selected__");
         run(DELETE_ALL_PATH, { ids: ids, mode: mode }, function (payload) {
-          var ok = payload.results.filter(function (result) {
-            return result.ok === true;
-          }).length;
-          var bytes = 0;
-          for (var i = 0; i < payload.results.length; i += 1) {
-            if (payload.results[i].ok && payload.results[i].removed) bytes += payload.results[i].removed.bytes || 0;
-          }
           setSelected({});
-          setNotice(
-            ok === payload.results.length
-              ? { kind: "ok", text: t("deletedMany", { n: ok, size: formatBytes(bytes) }) }
-              : { kind: "error", text: t("deletedPartial", { ok: ok, failed: payload.results.length - ok }) },
-          );
+          reportBatch(payload);
         });
       }
 
@@ -319,20 +362,7 @@ window.__ModuleLoader__.load({
           return row.id;
         });
         setBusy("__all__");
-        run(DELETE_ALL_PATH, { ids: ids, mode: mode }, function (payload) {
-          var ok = payload.results.filter(function (result) {
-            return result.ok === true;
-          }).length;
-          var bytes = 0;
-          for (var i = 0; i < payload.results.length; i += 1) {
-            if (payload.results[i].ok && payload.results[i].removed) bytes += payload.results[i].removed.bytes || 0;
-          }
-          setNotice(
-            ok === payload.results.length
-              ? { kind: "ok", text: t("deletedMany", { n: ok, size: formatBytes(bytes) }) }
-              : { kind: "error", text: t("deletedPartial", { ok: ok, failed: payload.results.length - ok }) },
-          );
-        });
+        run(DELETE_ALL_PATH, { ids: ids, mode: mode }, reportBatch);
       }
 
       function restoreRow(entry) {
@@ -366,10 +396,10 @@ window.__ModuleLoader__.load({
         });
       }
 
-      if (failed) {
+      if (failed !== null) {
         return h("div", { className: "dasm_section" }, [
           h("h2", { className: "dasm_title", key: "title" }, t("nav")),
-          h("p", { className: "dasm_status", key: "failed" }, t("hostUnavailable")),
+          h("p", { className: "dasm_status", key: "failed" }, t("hostUnavailable", { reason: failed })),
         ]);
       }
 
@@ -751,7 +781,7 @@ window.__ModuleLoader__.load({
       nav: "已归档",
       search: "搜索已归档会话",
       loading: "正在读取会话…",
-      hostUnavailable: "读不到宿主状态：请确认插件已随宿主加载，然后刷新页面。",
+      hostUnavailable: "读不到宿主状态（{reason}）：请确认插件已随宿主加载，然后刷新页面。",
       apiMismatch: "插件的前后端版本不一致：请重启 DSH 后再试。",
       empty: "暂无已归档会话。",
       emptySearch: "没有匹配的会话。",
@@ -820,7 +850,7 @@ window.__ModuleLoader__.load({
       nav: "Archived",
       search: "Search archived sessions",
       loading: "Reading sessions…",
-      hostUnavailable: "Cannot read host state — check that the plugin loaded, then refresh.",
+      hostUnavailable: "Cannot read host state ({reason}) — check that the plugin loaded, then refresh.",
       apiMismatch: "The plugin's two halves disagree on the API version — restart DSH and try again.",
       empty: "No archived sessions.",
       emptySearch: "No matching sessions.",

package/lib/host/paths.js

@@ -18,8 +18,87 @@ import { readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
-/** Session ids this plugin is willing to touch: the canonical `session-<uuid>`. */
-export const SESSION_ID = /^session-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Ids the *store* and the *host API* accept. A session is `session-<uuid>`, but
+ * a session whose header carries no prefix at all is a bare uuid (imported
+ * transcripts and delegate imports both produce those).
+ */
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const IMPORT_PREFIXES = ["import-session-", "import-"];
+const CANONICAL_PREFIX = "session-";
+export const HOST_ID = new RegExp(`^(?:${CANONICAL_PREFIX})?${UUID}$`, "i");
+
+/**
+ * Ids an archived *row* may be filed under.
+ *
+ * DSH's own sessions are `session-<uuid>`, but the import feature namespaces the
+ * id it files in the archive index: `import-session-<uuid>` for an imported
+ * transcript and `import-<uuid>` for a delegate-imported session. Every one of
+ * those is a real archived row the panel draws, so all of them must be accepted.
+ * Refusing the import namespaces was a silent, total failure: the rows rendered
+ * fine and every delete came back `invalid-session-id`.
+ *
+ * The path-safety argument is unchanged — a bare uuid is the only shape any form
+ * may carry, so no form can introduce a separator, a `..`, or a NUL.
+ */
+export const SESSION_ID = new RegExp(`^(?:import-session-|import-|${CANONICAL_PREFIX})?${UUID}$`, "i");
+
+/** The raw id a registry entry names, with its import namespace peeled off. */
+export function canonicalSessionId(raw) {
+  const text = String(raw);
+  for (const prefix of IMPORT_PREFIXES) {
+    if (text.startsWith(prefix)) return text.slice(prefix.length);
+  }
+  return text;
+}
+
+/**
+ * Ordered ids the *filesystem* may know one archived row by.
+ *
+ * The archive index is namespaced; the session store is not. `import-<uuid>` and
+ * `import-session-<uuid>` both name a session whose directory (and whose log
+ * header `id`) is the bare uuid or `session-<uuid>`. `locateArtifacts` only ever
+ * accepts a directory whose decoded name is one of these, so a namespace
+ * collision cannot make the plugin delete a different session's log.
+ */
+export function artifactIdCandidates(raw) {
+  const text = String(raw);
+  const out = [text];
+  const add = (value) => {
+    if (value.length > 0 && !out.includes(value)) out.push(value);
+  };
+  // The import namespace wraps the store shape, so peeling it off is the first
+  // and usually only step. The other store form is added as a fallback, because
+  // each import form has been seen wrapping each store shape. Peeling `import-`
+  // off `import-session-<uuid>` would leave `session-session-<uuid>`, a name
+  // nothing on disk carries.
+  for (const prefix of IMPORT_PREFIXES) {
+    if (!text.startsWith(prefix)) continue;
+    const rest = text.slice(prefix.length);
+    add(rest);
+    add(CANONICAL_PREFIX + rest);
+  }
+  return out;
+}
+
+/**
+ * Inverse of DSH's `encodeSegment`: safe units stay literal and every other code
+ * unit is `~XXXX`. Lets a directory name be compared against the candidate ids
+ * instead of guessing at string prefixes.
+ */
+export function decodeSegment(name) {
+  let out = "";
+  for (let i = 0; i < name.length; i += 1) {
+    const ch = name[i];
+    if (ch !== "~") {
+      out += ch;
+      continue;
+    }
+    out += String.fromCharCode(parseInt(name.slice(i + 1, i + 5), 16));
+    i += 4;
+  }
+  return out;
+}
 
 export function dshHome() {
   const configured = process.env.DSH_HOME;
@@ -78,8 +157,20 @@ export function quarantineMetaFile(sessionId) {
   return join(quarantineEntry(sessionId), "meta.json");
 }
 
-/** Every on-disk artifact directory of one session (normally zero or one). */
+/**
+ * Every on-disk artifact directory of one session (normally zero or one).
+ *
+ * The directory is named after the id inside the session log's header, which is
+ * NOT always the id the archive index files the row under: an imported row is
+ * indexed as `import-session-<uuid>` / `import-<uuid>` while its directory is
+ * `session-<uuid>` or the bare uuid. Looking up the raw registry id therefore
+ * found nothing, so a delete freed the projection cache and the index entry and
+ * silently left the session log on disk — the exact "fake success" this plugin
+ * exists to prevent. Match on the decoded directory name instead.
+ */
 export async function locateArtifacts(sessionId) {
+  const candidates = artifactIdCandidates(sessionId);
+  const wanted = new Set(candidates.map((id) => id.toLowerCase()));
   const found = [];
   let workspaces;
   try {
@@ -89,8 +180,26 @@ export async function locateArtifacts(sessionId) {
   }
   for (const workspace of workspaces) {
     if (!workspace.isDirectory()) continue;
-    const candidate = join(sessionsRoot(), workspace.name, sessionId);
-    if (existsSync(candidate)) found.push(candidate);
+    const bucket = join(sessionsRoot(), workspace.name);
+    // The pre-encoded name is the common case; only fall back to decoding the
+    // bucket's entries when it is absent (an id that needed `encodeSegment`).
+    const direct = candidates.map((id) => join(bucket, id)).find((path) => existsSync(path));
+    if (direct !== undefined) {
+      found.push(direct);
+      continue;
+    }
+    let entries;
+    try {
+      entries = await readdir(bucket, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (!wanted.has(decodeSegment(entry.name).toLowerCase())) continue;
+      found.push(join(bucket, entry.name));
+      break;
+    }
   }
   return found;
 }

package/lib/host/quarantine.js

@@ -14,6 +14,7 @@ import { constants } from "node:fs";
 import { access, cp, mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import {
+  canonicalSessionId,
   directorySize,
   projectionCacheFile,
   quarantineArtifactDir,
@@ -133,8 +134,13 @@ export async function restoreSession(ctx, sessionId, entry) {
   const artifact = quarantineArtifactDir(sessionId);
   const cache = quarantineCacheFile(sessionId);
   const restored = { directories: 0, cache: false, rearchived: false };
+  // The registry id may be namespaced (`import-…`), while the log directory and
+  // the projection-cache document are named after the raw session id. Restoring
+  // under the registry id would put the directory back under a name nothing
+  // looks for again.
+  const rawId = canonicalSessionId(sessionId);
 
-  const target = entry.workspaceDir !== null ? join(entry.workspaceDir, sessionId) : null;
+  const target = entry.workspaceDir !== null ? join(entry.workspaceDir, rawId) : null;
   if (await exists(artifact)) {
     if (target === null) throw new Error("quarantine metadata has no workspaceDir");
     await mkdir(dirname(target), { recursive: true });
@@ -142,7 +148,7 @@ export async function restoreSession(ctx, sessionId, entry) {
     restored.directories = 1;
   }
   if (await exists(cache)) {
-    await movePath(cache, projectionCacheFile(sessionId));
+    await movePath(cache, projectionCacheFile(rawId));
     restored.cache = true;
   }
   await rm(root, { recursive: true, force: true });

package/lib/host/trust.js

@@ -1,14 +1,29 @@
 // Request trust for the destructive routes.
 //
-// Loopback, marker-header, same-origin. The routes are destructive, so they
+// Loopback, and provably not cross-site. The routes are destructive, so they
 // refuse anything that is not this browser talking to this server.
 //
-// `Origin` is authoritative when present, but browsers omit it on same-origin
-// GETs — so that case falls back to Fetch Metadata's `sec-fetch-site`, which a
-// cross-site caller cannot forge. A request with neither signal is refused.
+// The shipped web client is not the only client: the Desktop app talks to the
+// same host, and a request that reaches us through the app's own pipeline can
+// arrive without the Fetch Metadata headers a page-initiated fetch carries.
+// Requiring `sec-fetch-site: same-origin` outright therefore rejected the
+// Desktop app's perfectly legitimate same-origin call. What actually has to
+// hold is: loopback, not cross-site, and either the marker header or a proven
+// same-origin signal.
+//
+//   * cross-site is always refused — that is the CSRF case, and every browser
+//     that matters sends `sec-fetch-site` for it;
+//   * `Origin`, when present, must match `Host` (browsers omit it on
+//     same-origin GETs, which is why it cannot be required);
+//   * a request with no signals at all needs the marker header, which a
+//     cross-origin page cannot set without a preflight this server never
+//     approves.
 
 export const HEADER = "x-dsh-archived";
 
+/** The pre-rename marker, still accepted so an open tab survives the rename. */
+export const LEGACY_HEADER = "x-dsh-archived-sessions";
+
 export function header(request, key) {
   const value = request.headers?.[key];
   return Array.isArray(value) ? value[0] : value;
@@ -25,15 +40,8 @@ export function isLoopbackAddress(value) {
   );
 }
 
-export function isTrustedRequest(request) {
-  if (header(request, HEADER) !== "1") return false;
-  if (!isLoopbackAddress(request.socket?.remoteAddress)) return false;
-  const site = header(request, "sec-fetch-site");
-  if (site !== undefined && site !== "same-origin") return false;
-  const host = header(request, "host");
-  if (!host) return false;
-  const origin = header(request, "origin");
-  if (origin === undefined) return site === "same-origin";
+/** Whether the request's `Origin` names this very host. */
+function originMatchesHost(origin, host) {
   try {
     const url = new URL(origin);
     return (
@@ -46,6 +54,46 @@ export function isTrustedRequest(request) {
   }
 }
 
+/**
+ * The full trust decision, with the evidence that produced it.
+ *
+ * @returns `{ trusted, ... }` — the reasons are kept so a refused request can
+ * be reported instead of vanishing, which is what made the Desktop-app failure
+ * invisible for a whole round of debugging.
+ */
+export function trustReport(request) {
+  const marker = header(request, HEADER) ?? header(request, LEGACY_HEADER);
+  const site = header(request, "sec-fetch-site");
+  const host = header(request, "host");
+  const origin = header(request, "origin");
+  const loopback = isLoopbackAddress(request.socket?.remoteAddress);
+  // A present Origin or Fetch Metadata signal is authoritative and cannot be
+  // overridden by the marker: a mismatch is fatal on its own.
+  const originOk = origin === undefined || originMatchesHost(origin, host);
+  const siteOk = site === undefined || site === "same-origin";
+  // A same-origin signal is something a cross-origin page cannot produce, so it
+  // proves the caller on its own. The marker covers the case where no Fetch
+  // Metadata header arrives at all (a non-browser client, or the Desktop app's
+  // own request pipeline).
+  const provenSameOrigin = (origin !== undefined && originOk) || site === "same-origin";
+  const trusted = loopback && Boolean(host) && originOk && siteOk && (marker === "1" || provenSameOrigin);
+  return {
+    trusted,
+    marker: marker ?? null,
+    loopback,
+    host: host ?? null,
+    site: site ?? null,
+    origin: origin ?? null,
+    originOk,
+    siteOk,
+    provenSameOrigin,
+  };
+}
+
+export function isTrustedRequest(request) {
+  return trustReport(request).trusted;
+}
+
 export function json(response, statusCode, value) {
   response.writeHead(statusCode, {
     "content-type": "application/json; charset=utf-8",

package/lib/index.js

@@ -31,6 +31,8 @@ import { dirname } from "node:path";
 
 import {
   SESSION_ID,
+  artifactIdCandidates,
+  canonicalSessionId,
   directorySize,
   dshHome,
   legacyAggregateFile,
@@ -54,18 +56,29 @@ import {
   quarantineSession,
   restoreSession,
 } from "./host/quarantine.js";
-import { failureDetail, isTrustedRequest, json, readJsonBody } from "./host/trust.js";
+import { failureDetail, json, readJsonBody, trustReport } from "./host/trust.js";
 
 export const name = "dsh-archived";
 export const inject = ["webServer", "workspaceRegistry", "agents", "sessions"];
 
 const BASE = "/api/dsh-archived";
-const STATE_PATH = BASE + "/state";
-const DELETE_PATH = BASE + "/delete";
-const DELETE_ALL_PATH = BASE + "/delete-all";
-const RESTORE_PATH = BASE + "/restore";
-const EMPTY_PATH = BASE + "/empty-quarantine";
-const REVEAL_PATH = BASE + "/reveal";
+
+/**
+ * The pre-rename prefix, still served so a tab that loaded the 0.2.0 client
+ * keeps working across the rename instead of stranding the user on an error
+ * page until they reload. The 0.2.0 client used the same six verbs, so the
+ * alias is a prefix swap and nothing more.
+ */
+const LEGACY_BASE = "/api/dsh-archived-sessions";
+/** Route suffixes, registered under both the current and the legacy prefix. */
+const SUFFIX = {
+  state: "/state",
+  delete: "/delete",
+  deleteAll: "/delete-all",
+  restore: "/restore",
+  empty: "/empty-quarantine",
+  reveal: "/reveal",
+};
 
 /** Wire version of the route contract, so the panel can detect a half-upgraded host. */
 export const API_VERSION = 2;
@@ -82,6 +95,26 @@ const sweeps = new Set();
 /** Session ids with a delete in flight, so two tabs cannot interleave on one row. */
 const inFlight = new Set();
 
+/**
+ * The last few refused requests, with the evidence that refused them. A 403
+ * that leaves no trace is undebuggable from the outside — which is exactly how
+ * the Desktop app ended up looking broken while every probe said it worked.
+ */
+const refusals = [];
+const MAX_REFUSALS = 20;
+
+function recordRefusal(path, request, report) {
+  refusals.push({
+    at: new Date().toISOString(),
+    path,
+    method: request.method,
+    remote: request.socket?.remoteAddress ?? null,
+    userAgent: String(request.headers?.["user-agent"] ?? "").slice(0, 80),
+    ...report,
+  });
+  if (refusals.length > MAX_REFUSALS) refusals.splice(0, refusals.length - MAX_REFUSALS);
+}
+
 /** The archive set's owner. `ctx.get` is the documented safe read; the property stays as a fallback. */
 function registryOf(ctx) {
   try {
@@ -99,6 +132,33 @@ function archivedIds(ctx) {
   return Array.isArray(ids) ? [...ids] : [];
 }
 
+/**
+ * Ids other than the archived row that could name the *live agent* of the same
+ * session. An imported row is indexed under a namespaced id
+ * (`import-session-<uuid>` / `import-<uuid>`) while the agent table, the session
+ * store and the on-disk directory all know the bare uuid, so a running-turn
+ * check done only against the archived id would miss a live agent and delete a
+ * session out from under it.
+ */
+function agentIdCandidates(sessionId) {
+  return artifactIdCandidates(sessionId).filter((id) => id !== sessionId);
+}
+
+/**
+ * Is any candidate id for this row a live agent running a turn? The archived id
+ * is checked by the caller (it is the form the host may broadcast), so only the
+ * remaining candidates are consulted here.
+ */
+function runningAlias(ctx, sessionId) {
+  return agentIdCandidates(sessionId).find((id) => isRunning(ctx, id)) ?? null;
+}
+
+/** The raw ids a delete had to look under, for an operator-facing log line. */
+function artifactHints(sessionId) {
+  const hints = artifactIdCandidates(sessionId).filter((id) => id !== sessionId);
+  return hints.length > 0 ? `, looked up as ${hints.join(" | ")}` : "";
+}
+
 /**
  * Whether this host still offers what a destructive route needs. A host whose
  * registry lost `unarchiveSession` cannot clear the archive index, and a delete
@@ -129,9 +189,10 @@ async function stateOf(ctx) {
     const dirs = await locateArtifacts(id);
     let bytes = 0;
     for (const dir of dirs) bytes += await directorySize(dir);
-    const cacheFile = projectionCacheFile(id);
+    const rawId = canonicalSessionId(id);
+    const cacheFile = projectionCacheFile(rawId);
     const cache = existsSync(cacheFile);
-    const document = cache ? await readCacheDocument(id) : null;
+    const document = cache ? await readCacheDocument(rawId) : null;
     items.push({
       id,
       archived: true,
@@ -155,6 +216,7 @@ async function stateOf(ctx) {
     home: dshHome(),
     items,
     quarantine: { count: parked.length, bytes: sumBytes(parked), items: parked },
+    refusals: refusals.slice().reverse(),
     legacy: {
       present: existsSync(legacyAggregateFile()),
       rows: legacyRows === null ? null : legacyRows.size,
@@ -193,7 +255,7 @@ async function sweepResidue(ctx, sessionId) {
   if (archivedIds(ctx).includes(sessionId)) return;
   if (isRunning(ctx, sessionId)) return;
   if ((await locateArtifacts(sessionId)).length > 0) return;
-  const cacheFile = projectionCacheFile(sessionId);
+  const cacheFile = projectionCacheFile(canonicalSessionId(sessionId));
   if (existsSync(cacheFile)) await rm(cacheFile, { force: true });
 }
 
@@ -217,12 +279,17 @@ async function deleteOne(ctx, sessionId, mode) {
   if (!hostSupportsDelete(ctx)) return refuse("no-registry", { sessionId });
   if (!archivedIds(ctx).includes(sessionId)) return refuse("not-archived", { sessionId });
   if (isRunning(ctx, sessionId)) return refuse("session-running", { sessionId });
+  const alias = runningAlias(ctx, sessionId);
+  if (alias !== null) return refuse("session-running", { sessionId, runningAs: alias });
   const descendants = runningDescendants(ctx, sessionId);
   if (descendants.length > 0) return refuse("subagent-running", { sessionId, descendants });
 
   return withLock(sessionId, async () => {
+    // The archive index is namespaced; the log directory, the projection cache
+    // document and the host's own session store all use the raw id.
+    const rawId = canonicalSessionId(sessionId);
     const dirs = await locateArtifacts(sessionId);
-    const cacheFile = projectionCacheFile(sessionId);
+    const cacheFile = projectionCacheFile(rawId);
     let bytes = 0;
     for (const dir of dirs) bytes += await directorySize(dir);
 
@@ -241,7 +308,7 @@ async function deleteOne(ctx, sessionId, mode) {
       // and that the panel would not even show.
       removed = { directories: 0, bytes: 0, cache: false, parked: false };
     } else {
-      const document = existsSync(cacheFile) ? await readCacheDocument(sessionId) : null;
+      const document = existsSync(cacheFile) ? await readCacheDocument(rawId) : null;
       removed = await quarantineSession(sessionId, {
         dirs,
         cacheFile,
@@ -258,7 +325,7 @@ async function deleteOne(ctx, sessionId, mode) {
     await registryOf(ctx).unarchiveSession(sessionId);
     scheduleSweep(ctx, sessionId);
     ctx.logger?.info?.(
-      `[dsh-archived] delete ${sessionId} (${mode}): ${removed.directories} dir(s), ${removed.bytes} bytes`,
+      `[dsh-archived] delete ${sessionId} (${mode}): ${removed.directories} dir(s), ${removed.bytes} bytes${artifactHints(sessionId)}`,
     );
     return { ok: true, sessionId, mode, removed, archivedSessionIds: archivedIds(ctx) };
   });
@@ -331,8 +398,11 @@ function route(ctx, { path, method, handle }) {
             json(response, 405, { error: "method-not-allowed" });
             return;
           }
-          if (!isTrustedRequest(request)) {
-            json(response, 403, { error: "forbidden" });
+          const report = trustReport(request);
+          if (!report.trusted) {
+            recordRefusal(path, request, report);
+            ctx.logger?.warn?.(`[dsh-archived] refused ${request.method} ${path}: ${JSON.stringify(report)}`);
+            json(response, 403, { error: "forbidden", detail: report });
             return;
           }
           try {
@@ -350,37 +420,39 @@ function route(ctx, { path, method, handle }) {
 }
 
 export function apply(ctx) {
-  route(ctx, { path: STATE_PATH, method: "GET", handle: () => stateOf(ctx) });
-
-  route(ctx, {
-    path: DELETE_PATH,
-    method: "POST",
-    handle: (body) => deleteOne(ctx, body?.sessionId, body?.mode === "forever" ? "forever" : "quarantine"),
-  });
-
-  route(ctx, {
-    path: DELETE_ALL_PATH,
-    method: "POST",
-    handle: (body) => {
-      const mode = body?.mode === "forever" ? "forever" : "quarantine";
-      const ids = Array.isArray(body?.ids) ? body.ids : archivedIds(ctx);
-      return deleteMany(ctx, ids, mode);
+  const specs = [
+    { suffix: SUFFIX.state, method: "GET", handle: () => stateOf(ctx) },
+    {
+      suffix: SUFFIX.delete,
+      method: "POST",
+      handle: (body) => deleteOne(ctx, body?.sessionId, body?.mode === "forever" ? "forever" : "quarantine"),
     },
-  });
-
-  route(ctx, { path: RESTORE_PATH, method: "POST", handle: (body) => restoreOne(ctx, body?.sessionId) });
-
-  route(ctx, {
-    path: EMPTY_PATH,
-    method: "POST",
-    handle: async () => {
-      const parked = await listQuarantine();
-      for (const entry of parked) await purgeQuarantineEntry(entry.id);
-      return { ok: true, purged: parked.length, bytes: sumBytes(parked) };
+    {
+      suffix: SUFFIX.deleteAll,
+      method: "POST",
+      handle: (body) => {
+        const mode = body?.mode === "forever" ? "forever" : "quarantine";
+        const ids = Array.isArray(body?.ids) ? body.ids : archivedIds(ctx);
+        return deleteMany(ctx, ids, mode);
+      },
     },
-  });
-
-  route(ctx, { path: REVEAL_PATH, method: "POST", handle: (body) => revealOne(ctx, body?.sessionId) });
+    { suffix: SUFFIX.restore, method: "POST", handle: (body) => restoreOne(ctx, body?.sessionId) },
+    {
+      suffix: SUFFIX.empty,
+      method: "POST",
+      handle: async () => {
+        const parked = await listQuarantine();
+        for (const entry of parked) await purgeQuarantineEntry(entry.id);
+        return { ok: true, purged: parked.length, bytes: sumBytes(parked) };
+      },
+    },
+    { suffix: SUFFIX.reveal, method: "POST", handle: (body) => revealOne(ctx, body?.sessionId) },
+  ];
+  for (const spec of specs) {
+    for (const base of [BASE, LEGACY_BASE]) {
+      route(ctx, { path: base + spec.suffix, method: spec.method, handle: spec.handle });
+    }
+  }
 
   // A parked session is recoverable for a bounded window, then it expires on
   // its own so the quarantine can never become a second archive nobody drains.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-archived",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Archived-sessions page for DeepSeek Harness: per-row and batch deletion that clears the session log, the projection cache and the archive index together, with a 30-day recycle bin, subagent-aware refusals and a per-row disk footprint.",
   "type": "module",
   "main": "lib/index.js",