dsh-delete-chat 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 youqu68
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# dsh-delete-chat
+
+A DeepSeek Harness session manager: a settings page that lists every session and lets you archive (hide), unarchive (restore), and permanently delete sessions.
+
+一个 DeepSeek Harness 会话管理插件：在设置页中列出全部会话，并支持归档（隐藏）、取消归档（恢复显示）与永久删除会话。
+
+## What it does / 功能
+
+- **List** every session with its title, working directory, and creation time, split into *archived* and *active* groups.
+- **Archive** a session to hide it from the sidebar. The log is kept, so archiving is fully reversible.
+- **Unarchive** a session to make it visible again.
+- **Delete** a session permanently: removes its persistence log file, then detaches it from workspace accounting and from the archive set.
+
+## Install / 安装
+
+```sh
+dsh plugin --profile web add dsh-delete-chat
+```
+
+The package declares `dsh.bundle.patch`, so the command installs it **and** reconciles it into `dsh.profile.bundles` — no profile file editing. Restart `dsh web` to mount it.
+
+## Usage / 使用
+
+Open **Settings → 会话管理** (Session Manager).
+
+## Safety / 安全边界
+
+- **Archive is not delete.** Archiving only hides a session; its log stays on disk and `取消归档` restores it.
+- **Live sessions cannot be deleted.** A running session's delete button is disabled, and the host refuses the call even if it is reached directly.
+- **Delete is permanent and two-step.** The first click shows the exact file path that will be removed; only a second click deletes anything.
+- **Only the session's own artifact is touched.** The host resolves the path through `sessionPersistence.locate()`, refuses anything whose filename is not `session.jsonl*`, and refuses backends that expose no per-session artifact (for example a SQLite store).
+- **Sandbox-aware.** Session files live under `$DSH_HOME/sessions`, outside the workspace. If the host's shell sandbox denies the removal, the plugin surfaces that denial instead of forcing it, and the file can be deleted by hand.
+- **Search index.** A deleted session disappears from the session list immediately; a full-text search index may keep a stale row until the next DSH restart, which is the documented reconciliation point.
+
+## Architecture / 结构
+
+One dual-face package:
+
+| Piece | File | Role |
+| --- | --- | --- |
+| Host plugin | `lib/index.js` | `apply(ctx)` provides the `delChat` service |
+| Host manifest | `lib/typert.host.js` | the `./typert` Typert contribution that exposes `delChat` over the gateway |
+| Browser plugin | `lib/client.js` | the `settings.section` page, mounted through `exports["./client"]` |
+| Mount | `cordis.patch.yml` | one `insert` row: `del-chat → dsh-delete-chat` |
+
+The browser half reaches the host through `remote.delChat.*`. The host half imports no `@deepseek-ai/*` runtime package — it reads the host process's own services with `ctx.get(...)` and binds itself to the gateway with a hand-written `typertRemote` binding, so no code-generation step is needed to build this plugin.
+
+Exposed Remote methods:
+
+```
+delChat.list()                      → { sessions: [...] }
+delChat.archive({ sessionId })      → { archivedSessionIds: [...] }
+delChat.unarchive({ sessionId })    → { archivedSessionIds: [...] }
+delChat.inspectDelete({ sessionId })→ { deletable, reason, path, dir }
+delChat.deleteSession({ sessionId })→ { path }
+```
+
+## Development / 开发
+
+```sh
+npm install
+npm run build     # esbuild → lib/index.js, lib/typert.host.js, lib/client.js
+npm test          # structural validation of both halves
+```
+
+`npm run build` writes the published artifacts:
+
+- `lib/index.js` — the host plugin, bundled to ESM.
+- `lib/typert.host.js` — copied verbatim from `src/typert.host.js`.
+- `lib/client.js` — the browser bundle wrapped in the `window.__ModuleLoader__.load({ id, factory })` envelope the DSH client module system executes, with `react` left external for the shell's static module table.
+
+`npm test` imports the built host half against a mock Cordis context (exports, provided service, `typertRemote` binding, manifest shape) and executes the built browser bundle against a fake `window.__ModuleLoader__` plus a react shim, asserting the registration id, the exports, the Remote descriptors, and the `settings.section` registration.
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,10 @@
+# dsh-delete-chat bundle patch: one dual-face row over the web profile.
+#
+# The row name resolves from the profile's own node_modules, where
+# `dsh plugin --profile web add dsh-delete-chat` installed this package. The same
+# package carries the host half (the `delChat` Remote service) and the browser
+# half (exports["./client"], discovered through the dsh.client declaration), so
+# a single insert is the whole mount.
+- insert:
+    - id: del-chat
+      name: dsh-delete-chat

package/lib/client.js

@@ -0,0 +1,350 @@
+// Generated by scripts/build.mjs — do not edit directly.
+window.__ModuleLoader__.load({
+  id: "dsh-delete-chat",
+  factory: function (require) {
+    var module = { exports: {} };
+    var exports = module.exports;
+    (function (module, exports, require) {
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.js
+var client_exports = {};
+__export(client_exports, {
+  apply: () => apply,
+  inject: () => inject
+});
+module.exports = __toCommonJS(client_exports);
+var import_react = __toESM(require("react"), 1);
+var inject = ["remote"];
+var PACKAGE = "dsh-delete-chat";
+var NAMESPACE = "delChat";
+var SECTION_ID = "del-chat";
+var CSS_TAG = "dsh-delete-chat/client.css";
+var e = import_react.default.createElement;
+function codecOf(parse) {
+  return { parse };
+}
+var anyCodec = codecOf((value) => value);
+var codec = (typeName) => ({
+  mode: "strict",
+  typeSymbol: `${PACKAGE}#${typeName}`,
+  schema: anyCodec
+});
+var REMOTE_CONTRIBUTION = {
+  package: PACKAGE,
+  descriptors: [
+    {
+      id: `${PACKAGE}#${NAMESPACE}/list`,
+      service: NAMESPACE,
+      namespace: NAMESPACE,
+      method: "list",
+      invocation: { kind: "direct" },
+      parameters: [{ name: "request", wire: "request", source: "json", codec: codec("ListRequest") }],
+      result: codec("ListResult")
+    },
+    {
+      id: `${PACKAGE}#${NAMESPACE}/archive`,
+      service: NAMESPACE,
+      namespace: NAMESPACE,
+      method: "archive",
+      invocation: { kind: "direct" },
+      parameters: [{ name: "request", wire: "request", source: "json", codec: codec("SessionRequest") }],
+      result: codec("ArchivedIdsResult")
+    },
+    {
+      id: `${PACKAGE}#${NAMESPACE}/unarchive`,
+      service: NAMESPACE,
+      namespace: NAMESPACE,
+      method: "unarchive",
+      invocation: { kind: "direct" },
+      parameters: [{ name: "request", wire: "request", source: "json", codec: codec("SessionRequest") }],
+      result: codec("ArchivedIdsResult")
+    },
+    {
+      id: `${PACKAGE}#${NAMESPACE}/inspectDelete`,
+      service: NAMESPACE,
+      namespace: NAMESPACE,
+      method: "inspectDelete",
+      invocation: { kind: "direct" },
+      parameters: [{ name: "request", wire: "request", source: "json", codec: codec("SessionRequest") }],
+      result: codec("InspectDeleteResult")
+    },
+    {
+      id: `${PACKAGE}#${NAMESPACE}/deleteSession`,
+      service: NAMESPACE,
+      namespace: NAMESPACE,
+      method: "deleteSession",
+      invocation: { kind: "direct" },
+      parameters: [{ name: "request", wire: "request", source: "json", codec: codec("SessionRequest") }],
+      result: codec("DeleteResult")
+    }
+  ]
+};
+var CSS = [
+  ".dc-root{display:flex;flex-direction:column;gap:16px;font-size:13px}",
+  ".dc-head{display:flex;align-items:center;justify-content:space-between}",
+  ".dc-head-title{font-weight:600;font-size:15px}",
+  ".dc-section{border:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.35));border-radius:10px;padding:10px 12px}",
+  ".dc-section-title{font-weight:600;margin-bottom:8px;opacity:.85}",
+  ".dc-row{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:8px 0;border-top:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.18))}",
+  ".dc-row:first-of-type{border-top:0}",
+  ".dc-row-main{min-width:0;flex:1}",
+  ".dc-row-title{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}",
+  ".dc-row-sub{opacity:.6;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;margin-top:2px}",
+  ".dc-empty{opacity:.5;padding:4px 0}",
+  ".dc-live{color:var(--dsw-alias-state-info-primary,#4aa3e0);font-size:11px;margin-top:2px}",
+  ".dc-warn{color:var(--dsw-alias-state-warn-primary,#e0a060);font-size:11px;margin-top:4px;word-break:break-all}",
+  ".dc-actions{display:flex;align-items:center;gap:8px;flex-shrink:0}",
+  ".dc-btn{font:inherit;font-size:12px;color:inherit;background:var(--dsw-alias-button-elevated-fill,transparent);border:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.4));border-radius:7px;padding:4px 10px;cursor:pointer;white-space:nowrap}",
+  ".dc-btn:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(128,128,128,.15))}",
+  ".dc-btn:disabled{opacity:.4;cursor:default}",
+  ".dc-btn-restore{border-color:var(--dsw-alias-state-ok-primary,rgba(80,160,120,.6))}",
+  ".dc-btn-delete{color:var(--dsw-alias-state-error-primary,#d06c6c);border-color:var(--dsw-alias-state-error-primary,rgba(208,108,108,.5))}",
+  ".dc-btn-danger{background:var(--dsw-alias-state-error-primary,#b5433f);border-color:transparent;color:var(--dsw-alias-label-primary-inverted,#fff)}",
+  ".dc-error{color:var(--dsw-alias-state-error-primary,#e06c6c);font-size:12px;white-space:pre-wrap}",
+  ".dc-loading{opacity:.6}"
+].join("");
+function insertCss() {
+  if (typeof document === "undefined") return () => {
+  };
+  if (document.querySelector(`style[data-plugin-css="${CSS_TAG}"]`) !== null) return () => {
+  };
+  const style = document.createElement("style");
+  style.dataset.plugin = PACKAGE;
+  style.dataset.pluginCss = CSS_TAG;
+  style.textContent = CSS;
+  document.head.appendChild(style);
+  return () => {
+    if (style.parentNode !== null) style.parentNode.removeChild(style);
+  };
+}
+async function call(remote, method, args) {
+  const carried = await remote[method](...args ?? []);
+  if (carried === null || typeof carried !== "object" || carried.ok !== true) {
+    throw new Error(carried && carried.error && carried.error.message || `${method} \u8C03\u7528\u5931\u8D25`);
+  }
+  return carried.value;
+}
+function formatTime(ms) {
+  try {
+    return new Date(ms).toLocaleString();
+  } catch {
+    return String(ms);
+  }
+}
+function SessionManagerPage(props) {
+  const api = props.api;
+  const [view, setView] = import_react.default.useState({
+    loading: true,
+    sessions: [],
+    error: null,
+    busyId: null,
+    confirmId: null,
+    confirmPath: null
+  });
+  const load = async () => {
+    setView((s) => ({ ...s, loading: true }));
+    try {
+      const value = await call(api, "list", [{}]);
+      setView({
+        loading: false,
+        sessions: value && value.sessions || [],
+        error: null,
+        busyId: null,
+        confirmId: null,
+        confirmPath: null
+      });
+    } catch (error) {
+      setView({
+        loading: false,
+        sessions: [],
+        error: String(error && error.message || error),
+        busyId: null,
+        confirmId: null,
+        confirmPath: null
+      });
+    }
+  };
+  import_react.default.useEffect(() => {
+    load();
+  }, []);
+  const toggleArchive = async (sessionId, archived2) => {
+    setView((s) => ({ ...s, busyId: sessionId, error: null }));
+    try {
+      await call(api, archived2 ? "unarchive" : "archive", [{ sessionId }]);
+      await load();
+    } catch (error) {
+      setView((s) => ({ ...s, busyId: null, error: String(error && error.message || error) }));
+    }
+  };
+  const askDelete = async (sessionId) => {
+    setView((s) => ({ ...s, busyId: sessionId, error: null, confirmPath: null }));
+    try {
+      const info = await call(api, "inspectDelete", [{ sessionId }]);
+      if (info && info.deletable === true) {
+        setView((s) => ({ ...s, busyId: null, confirmId: sessionId, confirmPath: info.path }));
+      } else {
+        setView((s) => ({
+          ...s,
+          busyId: null,
+          confirmId: null,
+          confirmPath: null,
+          error: info && info.reason || "\u65E0\u6CD5\u5220\u9664"
+        }));
+      }
+    } catch (error) {
+      setView((s) => ({
+        ...s,
+        busyId: null,
+        confirmId: null,
+        confirmPath: null,
+        error: String(error && error.message || error)
+      }));
+    }
+  };
+  const doDelete = async (sessionId) => {
+    setView((s) => ({ ...s, busyId: sessionId, error: null }));
+    try {
+      await call(api, "deleteSession", [{ sessionId }]);
+      await load();
+    } catch (error) {
+      setView((s) => ({
+        ...s,
+        busyId: null,
+        confirmId: null,
+        confirmPath: null,
+        error: String(error && error.message || error)
+      }));
+    }
+  };
+  const renderRow = (session) => {
+    const confirming = view.confirmId === session.id;
+    const busy = view.busyId === session.id;
+    return e(
+      "div",
+      { key: session.id, className: "dc-row" },
+      e(
+        "div",
+        { className: "dc-row-main" },
+        e("div", { className: "dc-row-title" }, session.title || "(\u672A\u547D\u540D\u4F1A\u8BDD)"),
+        e(
+          "div",
+          { className: "dc-row-sub" },
+          (session.cwd || "(\u65E0\u5DE5\u4F5C\u76EE\u5F55)") + " \xB7 " + formatTime(session.createdAt)
+        ),
+        session.live ? e("div", { className: "dc-live" }, "\u25CF \u8FD0\u884C\u4E2D\uFF08\u4E0D\u53EF\u5220\u9664\uFF09") : null,
+        confirming ? e(
+          "div",
+          { className: "dc-warn" },
+          "\u5C06\u6C38\u4E45\u5220\u9664\u8BE5\u4F1A\u8BDD\u65E5\u5FD7\u6587\u4EF6\uFF0C\u4E0D\u53EF\u64A4\u9500\uFF1A" + (view.confirmPath || "")
+        ) : null
+      ),
+      e(
+        "div",
+        { className: "dc-actions" },
+        e(
+          "button",
+          {
+            className: "dc-btn" + (session.archived ? " dc-btn-restore" : ""),
+            disabled: busy,
+            onClick: () => toggleArchive(session.id, session.archived)
+          },
+          session.archived ? "\u53D6\u6D88\u5F52\u6863" : "\u5F52\u6863"
+        ),
+        confirming ? e(
+          "button",
+          { className: "dc-btn dc-btn-danger", disabled: busy, onClick: () => doDelete(session.id) },
+          "\u786E\u8BA4\u5220\u9664"
+        ) : e(
+          "button",
+          {
+            className: "dc-btn dc-btn-delete",
+            disabled: session.live || busy,
+            onClick: () => askDelete(session.id)
+          },
+          "\u5220\u9664"
+        ),
+        confirming ? e(
+          "button",
+          {
+            className: "dc-btn",
+            onClick: () => setView((s) => ({ ...s, confirmId: null, confirmPath: null }))
+          },
+          "\u53D6\u6D88"
+        ) : null
+      )
+    );
+  };
+  const renderSection = (title, sessions) => e(
+    "div",
+    { className: "dc-section" },
+    e("div", { className: "dc-section-title" }, title + "\uFF08" + sessions.length + "\uFF09"),
+    sessions.length === 0 ? e("div", { className: "dc-empty" }, "\u65E0") : sessions.map(renderRow)
+  );
+  const archived = view.sessions.filter((s) => s.archived);
+  const active = view.sessions.filter((s) => !s.archived);
+  return e(
+    "div",
+    { className: "dc-root" },
+    e(
+      "div",
+      { className: "dc-head" },
+      e("div", { className: "dc-head-title" }, "\u4F1A\u8BDD\u7BA1\u7406"),
+      e("button", { className: "dc-btn", onClick: load }, "\u5237\u65B0")
+    ),
+    view.error ? e("div", { className: "dc-error" }, "\u9519\u8BEF\uFF1A" + view.error) : null,
+    view.loading ? e("div", { className: "dc-loading" }, "\u52A0\u8F7D\u4E2D\u2026") : e("div", null, renderSection("\u5DF2\u5F52\u6863\uFF08\u53EF\u6062\u590D\u663E\u793A\uFF09", archived), renderSection("\u6B63\u5E38\u4F1A\u8BDD", active))
+  );
+}
+async function apply(ctx) {
+  const remote = ctx.remote;
+  if (remote === void 0 || typeof remote.$mount !== "function") return;
+  const unmount = await remote.$mount(REMOTE_CONTRIBUTION);
+  ctx.effect(() => () => {
+    unmount();
+  }, "del-chat: remote contribution");
+  const api = ctx.get("remote." + NAMESPACE);
+  if (api === void 0) return;
+  const removeCss = insertCss();
+  ctx.effect(() => () => removeCss(), "del-chat: stylesheet");
+  const slots = ctx.get("slots");
+  if (slots === void 0) return;
+  slots.inject(
+    "settings.section",
+    () => slots.register(
+      { name: "settings.section", id: SECTION_ID, order: 50, label: "\u4F1A\u8BDD\u7BA1\u7406" },
+      (props) => e(SessionManagerPage, { ...props, api })
+    )
+  );
+}
+
+    })(module, exports, require);
+    return module.exports;
+  },
+});

package/lib/index.js

@@ -0,0 +1,179 @@
+// Generated by scripts/build.mjs — do not edit directly.
+
+// src/index.js
+var name = "del-chat";
+function archivedIdsOf(registry) {
+  if (registry === void 0) return [];
+  try {
+    return registry.archivedSessionIds.map((id) => String(id));
+  } catch {
+    return [];
+  }
+}
+function parentDir(p) {
+  const i = Math.max(p.lastIndexOf("\\"), p.lastIndexOf("/"));
+  return i > 0 ? p.slice(0, i) : p;
+}
+async function inspectDeletable(ctx, sessionId) {
+  const sessions = ctx.get("sessions");
+  if (sessions !== void 0 && sessions.get(sessionId) !== void 0) {
+    return { deletable: false, reason: "\u8BE5\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\uFF0C\u65E0\u6CD5\u5220\u9664", path: null, dir: null };
+  }
+  const persistence = ctx.get("sessionPersistence");
+  if (persistence === void 0) {
+    return { deletable: false, reason: "\u5B58\u50A8\u670D\u52A1\u4E0D\u53EF\u7528", path: null, dir: null };
+  }
+  let header;
+  try {
+    const list = await persistence.list();
+    header = list.find((h) => String(h.id) === sessionId);
+  } catch {
+    header = void 0;
+  }
+  if (header === void 0) {
+    return { deletable: false, reason: "\u4F1A\u8BDD\u4E0D\u5B58\u5728", path: null, dir: null };
+  }
+  if (persistence.supportsRawArtifacts !== true) {
+    return { deletable: false, reason: "\u5F53\u524D\u5B58\u50A8\u540E\u7AEF\u4E0D\u66B4\u9732\u5355\u4F1A\u8BDD\u6587\u4EF6\uFF0C\u65E0\u6CD5\u5B89\u5168\u5220\u9664", path: null, dir: null };
+  }
+  const loc = persistence.locate(header);
+  if (loc === void 0 || loc.kind !== "jsonl") {
+    return { deletable: false, reason: "\u65E0\u6CD5\u89E3\u6790\u4F1A\u8BDD\u6587\u4EF6\u8DEF\u5F84", path: null, dir: null };
+  }
+  const base = String(loc.path).split(/[\\/]/).pop() ?? "";
+  if (!base.startsWith("session.jsonl")) {
+    return { deletable: false, reason: "\u4EA7\u7269\u6587\u4EF6\u540D\u5F02\u5E38\uFF0C\u5DF2\u62D2\u7EDD\u5220\u9664", path: null, dir: null };
+  }
+  return { deletable: true, reason: null, path: String(loc.path), dir: parentDir(String(loc.path)) };
+}
+function createService(ctx) {
+  const service = {
+    /** Every session, newest first inside each archive group. */
+    async list() {
+      const query = ctx.get("sessionQuery");
+      const registry = ctx.get("workspaceRegistry");
+      const sessions = ctx.get("sessions");
+      const archivedIds = archivedIdsOf(registry);
+      const archivedSet = new Set(archivedIds);
+      if (query === void 0) return { sessions: [] };
+      const records = await query.listSessions();
+      const titles = /* @__PURE__ */ new Map();
+      try {
+        const ids = records.map((r) => String(r.header.id));
+        const results = await query.readTitleSnapshots(ids);
+        for (const item of results) {
+          if (item.status === "fulfilled" && item.value && item.value.title && item.value.title.title) {
+            titles.set(String(item.sessionId), String(item.value.title.title));
+          }
+        }
+      } catch {
+      }
+      const liveSet = /* @__PURE__ */ new Set();
+      if (sessions !== void 0) {
+        for (const s of sessions.list()) liveSet.add(String(s.id));
+      }
+      const out = records.map((r) => {
+        const id = String(r.header.id);
+        const title = titles.get(id);
+        const cwd = r.header.cwd;
+        return {
+          id,
+          title: typeof title === "string" && title.length > 0 ? title : null,
+          cwd: typeof cwd === "string" && cwd.length > 0 ? cwd : null,
+          createdAt: Number(r.header.createdAt) || 0,
+          live: liveSet.has(id) || r.live === true,
+          archived: archivedSet.has(id)
+        };
+      });
+      out.sort((a, b) => a.archived === b.archived ? b.createdAt - a.createdAt : a.archived ? -1 : 1);
+      return { sessions: out };
+    },
+    /** Archive (hide) one session durably. */
+    async archive(request) {
+      const registry = ctx.get("workspaceRegistry");
+      if (registry === void 0) throw new Error("workspace registry unavailable");
+      await registry.archiveSession(String(request.sessionId));
+      return { archivedSessionIds: archivedIdsOf(registry) };
+    },
+    /**
+     * Unarchive (restore) one session by removing it from the registry-global
+     * archive set. Goes through the registry's own state setter so its
+     * in-memory cache stays consistent with the durable domain.
+     */
+    async unarchive(request) {
+      const registry = ctx.get("workspaceRegistry");
+      const storageDomain = ctx.get("storageDomain");
+      if (registry === void 0 || storageDomain === void 0) {
+        throw new Error("workspace registry unavailable");
+      }
+      const domain = storageDomain.get("workspace");
+      if (domain === void 0) throw new Error("workspace domain unavailable");
+      const state = domain.global.get();
+      const archived = state.archivedSessionIds ?? [];
+      const next = archived.filter((id) => String(id) !== String(request.sessionId));
+      if (next.length === archived.length) {
+        return { archivedSessionIds: archived.map((id) => String(id)) };
+      }
+      const nextState = { ...state, archivedSessionIds: next };
+      if (typeof registry.setState === "function") {
+        await registry.setState(nextState);
+      } else {
+        await domain.global.set(nextState);
+        registry.state = nextState;
+      }
+      return { archivedSessionIds: next.map((id) => String(id)) };
+    },
+    /** Whether one session's log file can be deleted, and where it is. */
+    async inspectDelete(request) {
+      return await inspectDeletable(ctx, String(request.sessionId));
+    },
+    /**
+     * Permanently delete one non-live session's persistence log file, then
+     * detach it from workspace accounting and from the archive set.
+     */
+    async deleteSession(request) {
+      const sessionId = String(request.sessionId);
+      const info = await inspectDeletable(ctx, sessionId);
+      if (!info.deletable) throw new Error(info.reason ?? "session is not deletable");
+      const shell = ctx.get("shell");
+      if (shell === void 0) throw new Error("shell service unavailable");
+      const quoted = info.path.replace(/'/g, "''");
+      const spec = shell.resolve({ command: `Remove-Item -LiteralPath '${quoted}' -Force -ErrorAction Stop` });
+      const result = await shell.run(spec);
+      if (result.sandbox && result.sandbox.denied) {
+        throw new Error("\u6C99\u7BB1\u62D2\u7EDD\u4E86\u5220\u9664\uFF08\u4F1A\u8BDD\u6587\u4EF6\u4F4D\u4E8E\u5DE5\u4F5C\u533A\u4E4B\u5916\uFF09");
+      }
+      if (result.exitCode !== 0) {
+        throw new Error(`\u5220\u9664\u547D\u4EE4\u5931\u8D25\uFF08exit ${result.exitCode}\uFF09`);
+      }
+      try {
+        await service.unarchive({ sessionId });
+      } catch {
+      }
+      const registry = ctx.get("workspaceRegistry");
+      if (registry !== void 0) {
+        try {
+          for (const workspace of registry.list()) {
+            await workspace.detachSession(sessionId);
+          }
+        } catch {
+        }
+      }
+      return { path: info.path };
+    }
+  };
+  Object.defineProperty(service, "typertRemote", {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: { service, serviceKey: "delChat", namespace: "delChat" }
+  });
+  return service;
+}
+function apply(ctx) {
+  ctx.provide("delChat", createService(ctx));
+}
+export {
+  apply,
+  name
+};

package/lib/typert.host.js

@@ -0,0 +1,133 @@
+/**
+ * dsh-delete-chat — Host-face Typert manifest.
+ *
+ * Structurally identical to a `@deepseek-ai/dsh-typert-generator` artifact:
+ * `dsh-typert-loader` imports this module through the package's `./typert`
+ * export, validates it, and registers every invocation with the Typert
+ * gateway, which is what makes `remote.delChat.*` callable from the browser.
+ *
+ * Every codec must be `{ mode: 'strict', typeSymbol, schema }` with a zod v4
+ * schema — a bare zod schema is rejected at registration.
+ */
+import { z } from 'zod'
+
+const nonEmpty = z.string().min(1)
+
+/** One session row rendered by the settings page. */
+const sessionSchema = z.object({
+  id: nonEmpty,
+  title: z.union([z.string(), z.null()]),
+  cwd: z.union([z.string(), z.null()]),
+  createdAt: z.number(),
+  live: z.boolean(),
+  archived: z.boolean(),
+})
+
+const listRequestSchema = z.object({}).strict()
+const listResultSchema = z.object({ sessions: z.array(sessionSchema) })
+
+const sessionRequestSchema = z.object({ sessionId: nonEmpty })
+
+const archivedIdsResultSchema = z.object({ archivedSessionIds: z.array(z.string()) })
+
+const inspectDeleteResultSchema = z.object({
+  deletable: z.boolean(),
+  reason: z.union([z.string(), z.null()]),
+  path: z.union([z.string(), z.null()]),
+  dir: z.union([z.string(), z.null()]),
+})
+
+const deleteResultSchema = z.object({ path: z.string() })
+
+const listRequest$codec = {
+  mode: 'strict',
+  typeSymbol: 'dsh-delete-chat#ListRequest',
+  schema: listRequestSchema,
+}
+const list$codec = {
+  mode: 'strict',
+  typeSymbol: 'dsh-delete-chat#ListResult',
+  schema: listResultSchema,
+}
+const sessionRequest$codec = {
+  mode: 'strict',
+  typeSymbol: 'dsh-delete-chat#SessionRequest',
+  schema: sessionRequestSchema,
+}
+const archivedIds$codec = {
+  mode: 'strict',
+  typeSymbol: 'dsh-delete-chat#ArchivedIdsResult',
+  schema: archivedIdsResultSchema,
+}
+const inspectDelete$codec = {
+  mode: 'strict',
+  typeSymbol: 'dsh-delete-chat#InspectDeleteResult',
+  schema: inspectDeleteResultSchema,
+}
+const delete$codec = {
+  mode: 'strict',
+  typeSymbol: 'dsh-delete-chat#DeleteResult',
+  schema: deleteResultSchema,
+}
+
+export const sessionSchemaExport = sessionSchema
+
+export const TYPERT = {
+  package: 'dsh-delete-chat',
+  face: 'host',
+  schemas: [],
+  invocations: [
+    {
+      id: 'dsh-delete-chat#delChat/list',
+      service: 'delChat',
+      namespace: 'delChat',
+      method: 'list',
+      invocation: { kind: 'direct' },
+      parameters: [{ name: 'request', wire: 'request', source: 'json', codec: listRequest$codec }],
+      result: list$codec,
+    },
+    {
+      id: 'dsh-delete-chat#delChat/archive',
+      service: 'delChat',
+      namespace: 'delChat',
+      method: 'archive',
+      invocation: { kind: 'direct' },
+      parameters: [{ name: 'request', wire: 'request', source: 'json', codec: sessionRequest$codec }],
+      result: archivedIds$codec,
+    },
+    {
+      id: 'dsh-delete-chat#delChat/unarchive',
+      service: 'delChat',
+      namespace: 'delChat',
+      method: 'unarchive',
+      invocation: { kind: 'direct' },
+      parameters: [{ name: 'request', wire: 'request', source: 'json', codec: sessionRequest$codec }],
+      result: archivedIds$codec,
+    },
+    {
+      id: 'dsh-delete-chat#delChat/inspectDelete',
+      service: 'delChat',
+      namespace: 'delChat',
+      method: 'inspectDelete',
+      invocation: { kind: 'direct' },
+      parameters: [{ name: 'request', wire: 'request', source: 'json', codec: sessionRequest$codec }],
+      result: inspectDelete$codec,
+    },
+    {
+      id: 'dsh-delete-chat#delChat/deleteSession',
+      service: 'delChat',
+      namespace: 'delChat',
+      method: 'deleteSession',
+      invocation: { kind: 'direct' },
+      parameters: [{ name: 'request', wire: 'request', source: 'json', codec: sessionRequest$codec }],
+      result: delete$codec,
+    },
+  ],
+  model: {
+    services: [],
+    events: [],
+    objects: [],
+  },
+}
+
+export default TYPERT

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "dsh-delete-chat",
+  "version": "0.1.0",
+  "description": "Session manager for DeepSeek Harness: list, archive, unarchive and permanently delete sessions from a settings page.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./typert": {
+      "default": "./lib/typert.host.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web"
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node test/validate-host.mjs && node test/validate-client.mjs",
+    "prepublishOnly": "node scripts/build.mjs"
+  },
+  "dependencies": {
+    "zod": "^4.5.1"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.9"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "session",
+    "archive",
+    "delete"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/youqu68/dsh-delete-chat.git"
+  },
+  "license": "MIT"
+}