dsh-compact-relay 0.5.1 → 0.5.3

package/lib/actions/recover.js

@@ -24,11 +24,11 @@ function errorMessageOf(error) {
  */
 export async function recoverArchivedSession(deps, { sessionId } = {}) {
   if (typeof sessionId !== 'string' || sessionId.length === 0) {
-    throw actionError('recover', '缺少要恢复的会话 id');
+    throw actionError('recover', '缺少要恢复的会话 id', undefined, 400);
   }
   const registry = workspaceRegistryOf(deps.ctx);
   if (registry === null || typeof registry.unarchiveSession !== 'function') {
-    throw actionError('recover', '当前 DSH 宿主没有 Workspace 归档恢复接口，无法恢复旧会话');
+    throw actionError('recover', '当前 DSH 宿主没有 Workspace 归档恢复接口，无法恢复旧会话', undefined, 503);
   }
 
   const wasArchived = isSessionArchived(deps.ctx, sessionId);
@@ -36,7 +36,15 @@ export async function recoverArchivedSession(deps, { sessionId } = {}) {
     await registry.unarchiveSession(sessionId);
   } catch (error) {
     deps.log?.warn?.(`compact-relay: 恢复归档会话 ${sessionId} 失败：${errorMessageOf(error)}`);
-    throw actionError('recover', `恢复旧会话失败：${errorMessageOf(error)}`, error);
+    const unknown = error !== null && typeof error === 'object' && error.name === 'WorkspaceUnknownSessionError';
+    throw actionError(
+      'recover',
+      unknown
+        ? `恢复旧会话失败：宿主里找不到这个会话（${errorMessageOf(error)}）`
+        : `恢复旧会话失败：${errorMessageOf(error)}`,
+      error,
+      unknown ? 404 : 500,
+    );
   }
 
   return {
@@ -44,6 +52,11 @@ export async function recoverArchivedSession(deps, { sessionId } = {}) {
     // false 表示本来就没归档（幂等 no-op），仍然算「恢复成功」——调用方可以直接打开。
     recovered: wasArchived !== false,
     message: wasArchived === false ? '这个会话本来就没有归档，可直接打开。' : '已恢复旧会话，可从侧栏重新打开。',
-    archivedSessionIds: archivedSessionIdsOf(deps.ctx),
+    // 0.5.3 P3-a：只回数量 + 本次恢复的 id（不再回全量归档集合）。
+    archivedCount: (() => {
+      const ids = archivedSessionIdsOf(deps.ctx);
+      return Array.isArray(ids) ? ids.length : null;
+    })(),
+    newlyRecovered: wasArchived === false ? [] : [sessionId],
   };
 }

package/lib/actions/state.js

@@ -5,6 +5,7 @@
  * 直接调 dsh/pressure + dsh/session-view（不走这里）。客户端不再自己算阈值。
  */
 import { paletteForBothSchemes } from '../core/colors.js';
+import { favoriteStateOf } from '../dsh/favorites-file.js';
 import { adviceFor, ratioOf, thresholdsForWindow } from '../core/policy.js';
 import { nativePinnedRiskOf } from '../core/native-pin-risk.js';
 import { pinHealthOf } from '../core/pin-health.js';
@@ -238,9 +239,17 @@ export async function readState(deps, { sessionId, agent } = {}) {
   // 用它决定要不要先 unarchive（宿主拒绝打开归档会话；unarchive 幂等）。
   // 和 parentArchived 完全对称：各查各的 id，读不到 → null（不猜 false）。
   const nextArchived = next === null || next.childId === null ? null : isSessionArchived(deps.ctx, next.childId);
+  // 0.5.2 L 项：链上父会话（旧会话）是否在侧栏置顶 —— 强制归档的二次确认要提前说明
+  // 「归档会取消置顶」（宿主在同一笔写盘里 unpin）。没有父会话/读不到 → null（不猜）。
+  const parentPinned = chain === null || chain.parentId === null ? null : isSessionPinned(deps.ctx, chain.parentId);
   // 0.5.1 DCR-03：宿主有没有「恢复归档会话」的接缝（HTTP recover 动作调的就是它）。
   // 客户端拿不到 ctx.uiWorkspace.unarchiveSession 时据此隐藏「恢复旧会话」死入口。
-  const capabilities = { unarchive: typeof workspaceRegistryOf(deps.ctx)?.unarchiveSession === 'function' };
+  // 0.5.2 L 项：`forceArchive` = 宿主有没有 archiveSession（接力条据此显示「强制归档旧会话」；
+  // 缺这个接缝时隐藏入口——点了必然失败）。
+  const capabilities = {
+    unarchive: typeof workspaceRegistryOf(deps.ctx)?.unarchiveSession === 'function',
+    forceArchive: typeof workspaceRegistryOf(deps.ctx)?.archiveSession === 'function',
+  };
 
   return {
     revision: ++stateRevision,
@@ -265,6 +274,11 @@ export async function readState(deps, { sessionId, agent } = {}) {
       },
       atRisk: pinRisk,
     },
+    // 0.6：收藏（项目级 JSONL）→ 当前会话 seq 投影，守 32KB 帧预算。
+    favorites: favoriteStateOf(deps.ctx, target?.session),
+    // 0.5.3 P1-6：推荐收藏建议（模型打分后点亮星标，**不自动收藏**）。
+    // 只下发 seq / messageId / 分数 / 原因；没有建议时是空数组（老客户端忽略）。
+    favoriteSuggest: deps.favoriteWatch?.suggestionOf?.(target?.session?.id) ?? [],
     compactRange,
     // 0.3.5：compactRange 非 null 但无活 agent 时为 'no_agent'，其它情况 null。
     compactRangeReason,
@@ -289,11 +303,14 @@ export async function readState(deps, { sessionId, agent } = {}) {
     // 0.5.1 批 3：出站目标（next.childId）是否在同一归档集合里。父会话侧「去新会话」
     // 据此先恢复再切；没有出站记录或读不到归档集合 → null。只加不改。
     nextArchived,
+    // 0.5.2 L 项：入站父会话（旧会话）是否在侧栏置顶。强制归档的二次确认用它在
+    // 「会停止后台任务」之外再说明「归档会取消置顶」；没有父会话/读不到 → null（不猜）。
+    parentPinned,
     // 0.5.1 批 2：本会话（agent.session，不是 agent.id）是否在侧栏置顶。
     // 交接前客户端据此弹「归档会取消置顶」确认；读不到置顶集合 → null（不猜）。
     sessionPinned: target === null || target.session === undefined ? null : isSessionPinned(deps.ctx, target.session.id),
-    // 0.5.1 DCR-03：宿主能力位（目前只有「能不能恢复归档会话」）。老客户端忽略；
-    // 新客户端在缺 `unarchive` 能力时隐藏恢复入口，不把用户带进必然失败的入口。
+    // 0.5.1 DCR-03：宿主能力位（能不能恢复归档会话 / 能不能强制归档）。老客户端忽略；
+    // 新客户端在缺 `unarchive` 能力时隐藏恢复入口，缺 `forceArchive` 时隐藏强制归档入口。
     capabilities,
     // 0.3.1：模型判断的「适合压缩」断点位置（没有或已失效为 null）。
     compressHint: activeHint,

package/lib/adapters/commands.js

@@ -7,6 +7,7 @@
 import { betterCompact, previewBetterCompact, takePreviewPlan } from '../actions/better-compact.js';
 import { handoff } from '../actions/handoff.js';
 import { listPins, pinByIndex, pinLastTurn, unpinAll } from '../actions/pin.js';
+import { favoriteLast, listFavoriteSuggestions, listFavorites, markFavoriteInSession, readFavoriteFull, readFavoriteInfo, unfavoriteByIndex } from '../actions/favorite.js';
 import { testCompact } from '../actions/test-compact.js';
 import { errorText } from '../core/errors.js';
 
@@ -104,6 +105,41 @@ export function registerCommands(ctx, deps) {
       ),
   });
 
+  register({
+    name: 'favorite',
+    description: '收藏消息：/favorite 列表｜/favorite mark [序号] 收藏（不带序号=最后一条回复）｜/favorite last 收藏我刚发的｜/favorite <序号> 看体积｜/favorite <序号> read 读原文｜/favorite rm <序号> 取消',
+    input: { hint: 'list | mark [序号] | last | suggest | 序号 | 序号 read | rm 序号' },
+    handler: (invocation) =>
+      track(
+        (async () => {
+          try {
+            const raw = invocation.rawInput.trim();
+            const lower = raw.toLowerCase();
+            const agent = invocation.agent;
+            let outcome = null;
+            if (raw === '' || lower === 'list') outcome = listFavorites(deps, { agent });
+            else if (lower === 'last') outcome = favoriteLast(deps, { agent });
+            else if (lower === 'suggest') outcome = listFavoriteSuggestions(deps, { agent });
+            else if (/^mark$/i.test(raw)) outcome = markFavoriteInSession(deps, { agent });
+            else if (/^mark\s+\d+$/i.test(raw)) outcome = markFavoriteInSession(deps, { agent, seq: Number(raw.slice(4).trim()) });
+            else if (/^\d+$/.test(raw)) outcome = readFavoriteInfo(deps, { agent, index: Number(raw) });
+            else {
+              const readMatch = /^(\d+)\s+read$/i.exec(raw);
+              const rmMatch = /^rm\s+(\d+)$/i.exec(raw);
+              if (readMatch !== null) outcome = readFavoriteFull(deps, { agent, index: Number(readMatch[1]) });
+              else if (rmMatch !== null) outcome = unfavoriteByIndex(deps, { agent, index: Number(rmMatch[1]) });
+            }
+            if (outcome === null) {
+              return { kind: 'error', text: '用法：/favorite（列表）｜/favorite mark [序号]（收藏，不带序号=最后一条回复）｜/favorite last｜/favorite <序号>（看体积）｜/favorite <序号> read（读原文）｜/favorite rm <序号>（取消）' };
+            }
+            return success(outcome);
+          } catch (error) {
+            return failure(error, invocation.signal);
+          }
+        })(),
+      ),
+  });
+
   register({
     name: 'pin',
     description: '锁定重要消息：/pin 锁定最近一轮｜/pin list 按序号挑｜/pin clear 全部解锁',

package/lib/adapters/http.js

@@ -6,11 +6,13 @@
 import { betterCompact, cancelBetterCompact, previewBetterCompact } from '../actions/better-compact.js';
 import { readCompactDiffs } from '../actions/compact-diff.js';
 import { readDiagnostics } from '../actions/diagnostics.js';
+import { forceArchiveSession } from '../actions/force-archive.js';
 import { handoff, previewHandoff } from '../actions/handoff.js';
 import { listHandoffDocs, readHandoffDoc } from '../actions/handoff-docs.js';
 import { recoverArchivedSession } from '../actions/recover.js';
 import { readCompactRelayChain } from '../actions/relay-chain.js';
 import { togglePin } from '../actions/pin.js';
+import { markFavoriteBySeq, ownerAgentOfMessage, toggleFavorite, trialFavoriteScore } from '../actions/favorite.js';
 import { setNativeAutoCompactionEnabled } from '../actions/native-compaction.js';
 import { readState, resolveTarget } from '../actions/state.js';
 import { errorText } from '../core/errors.js';
@@ -423,6 +425,14 @@ export function registerHttp(webCtx, deps) {
           if (parsed.confirmUnpin !== undefined && typeof parsed.confirmUnpin !== 'boolean') {
             return send(res, 400, { ok: false, message: 'confirmUnpin 必须是 true/false（true = 确认归档并取消旧会话置顶）' });
           }
+          // 0.5.2 L 项：强制归档的破坏性动作只有用户点过二次确认才允许执行
+          // （confirmStop:true = 会停止旧会话上正在跑的 turn/subagent/job/schedule）。
+          if (parsed.confirmStop !== undefined && typeof parsed.confirmStop !== 'boolean') {
+            return send(res, 400, {
+              ok: false,
+              message: 'confirmStop 必须是 true/false（true = 确认停止旧会话上的任务后归档）',
+            });
+          }
           // 多数动作作用在具体会话上：缺 sessionId 或类型错时绝不能退化成「最后一个 agent」
           // （2026-10-19 debug：旧实现会压错会话）。
           // 例外：
@@ -431,13 +441,30 @@ export function registerHttp(webCtx, deps) {
           //     恒 400「缺少 sessionId」，于是「关闭自动压缩」永远写不进去、也看不到反馈。
           //   - recover 作用在**已归档**的旧会话上，它通常没有活 agent；不能走 resolveTarget
           //     （否则恒 409「没有活动会话」）。sessionId 由 recover 分支自己校验。
+          //   - force-archive 同样作用在**旧会话**（交接前的那个）上，通常没有活 agent 可解；
+          //     它自己的动作层会校验 sessionId 与 confirmStop，不走 resolveTarget。
           let agent = null;
-          if (parsed.action !== 'native-auto' && parsed.action !== 'recover') {
+          // favorite-toggle 例外：messageId 是宿主 UUID，客户端没带对 sessionId 也能由
+          // ownerAgentOfMessage 反查所属会话（2026-10-29 真机 BUG：多会话时点星静默失败）。
+          const sessionOptionalAction =
+            parsed.action === 'native-auto' ||
+            parsed.action === 'recover' ||
+            parsed.action === 'force-archive' ||
+            parsed.action === 'favorite-toggle' ||
+            parsed.action === 'favorite-mark';
+          if (!sessionOptionalAction) {
             if (typeof parsed.sessionId !== 'string' || parsed.sessionId.length === 0) {
               return send(res, 400, { ok: false, message: '缺少 sessionId' });
             }
             agent = resolveTarget(deps, { sessionId: parsed.sessionId });
             if (agent === null) return send(res, 409, { ok: false, message: '没有活动会话' });
+          } else if (
+            parsed.action === 'favorite-toggle' &&
+            typeof parsed.sessionId === 'string' &&
+            parsed.sessionId.length > 0
+          ) {
+            // 带了 sessionId 就按它取 agent；取不到（会话已关）也继续，后面按 messageId 反查。
+            agent = resolveTarget(deps, { sessionId: parsed.sessionId });
           }
 
           if (parsed.action === 'recover') {
@@ -449,6 +476,21 @@ export function registerHttp(webCtx, deps) {
             return send(res, 200, outcome);
           }
 
+          if (parsed.action === 'force-archive') {
+            // 0.5.2 L 项：用户确认「会停止旧会话上正在跑的任务」后强制归档（唯一 stopActivity 调用点）。
+            // 0.5.3 P2-1：这里不再提前 400 —— 已归档 + 没带确认应回 already（动作层先判幂等），
+            // 只有「真要归档」的路径才要求 confirmStop:true（动作层给 statusCode 400）。
+            if (parsed.confirmStop !== undefined && typeof parsed.confirmStop !== 'boolean') {
+              return send(res, 400, { ok: false, message: 'confirmStop 必须是 true/false（true = 确认停止旧会话上的任务后归档）' });
+            }
+            const outcome = await forceArchiveSession(deps, {
+              sessionId: parsed.sessionId,
+              confirmStop: parsed.confirmStop,
+              confirmUnpin: parsed.confirmUnpin,
+            });
+            return send(res, 200, outcome);
+          }
+
           if (parsed.action === 'preview') {
             // M6：只算不写——先告诉用户「要压哪段、多少 token」，再让他确认。
             // A3：返回 planId，confirm 会带着它回来校验「同一段范围」。
@@ -478,6 +520,62 @@ export function registerHttp(webCtx, deps) {
             const outcome = await betterCompact(deps, { agent, expected });
             return send(res, 200, { ok: true, message: outcome.message });
           }
+          if (parsed.action === 'favorite-score-trial') {
+            // 0.5.3 P1-7：设置页「试算」——对一段文本按当前（可覆盖）配置跑一次打分+判定。
+            // 只读：不写收藏、不影响任何状态；没有活会话拿不到模型路由时明确 409。
+            if (agent === null) return send(res, 409, { ok: false, message: '没有活动会话，无法试算（先发一条消息唤醒 agent）' });
+            const text = typeof parsed.text === 'string' ? parsed.text : '';
+            if ([...text.trim()].length === 0) return send(res, 400, { ok: false, message: '缺少要试算的文本' });
+            const outcome = await trialFavoriteScore(deps, {
+              agent,
+              text,
+              level: parsed.level,
+              mustWords: parsed.mustWords,
+              muteWords: parsed.muteWords,
+            });
+            return send(res, 200, { ok: true, ...outcome });
+          }
+          if (parsed.action === 'favorite-mark') {
+            // 0.5.3：标记层解耦——按 sessionId+seq 收藏，**不需要活会话**（归档/关闭的会话也能标）。
+            // 只写一行 JSONL；原文等压缩时落档，不读会话日志、不碰压缩。
+            if (parsed.active !== undefined && typeof parsed.active !== 'boolean') {
+              return send(res, 400, { ok: false, message: 'active 必须是 true/false（省略=切换）' });
+            }
+            try {
+              const outcome = await markFavoriteBySeq(deps, {
+                sessionId: parsed.sessionId,
+                seq: Number(parsed.seq),
+                active: parsed.active,
+              });
+              return send(res, 200, { ok: true, ...outcome });
+            } catch (error) {
+              const code = error !== null && typeof error === 'object' ? error.code : undefined;
+              return send(res, code === 'favorite' ? 400 : 500, {
+                ok: false,
+                ...(code === undefined ? {} : { code }),
+                message: errorText(error),
+              });
+            }
+          }
+          if (parsed.action === 'favorite-toggle') {
+            // 0.6：助手消息底部星标——按宿主 messageId 收藏/取消。
+            // 客户端 sessionId 可能缺失或过期：messageId 唯一，按它反查所属活会话。
+            const messageId =
+              typeof parsed.messageId === 'string' && parsed.messageId.length > 0 ? parsed.messageId : null;
+            if (messageId === null) return send(res, 400, { ok: false, message: '缺少 messageId' });
+            try {
+              const actor = agent ?? ownerAgentOfMessage(deps, messageId);
+              const outcome = toggleFavorite(deps, { agent: actor, messageId });
+              return send(res, 200, { ok: true, ...outcome });
+            } catch (error) {
+              const code = error !== null && typeof error === 'object' ? error.code : undefined;
+              return send(res, code === 'favorite' ? 400 : 500, {
+                ok: false,
+                ...(code === undefined ? {} : { code }),
+                message: errorText(error),
+              });
+            }
+          }
           if (parsed.action === 'pin-toggle') {
             // M6：菜单「锁定重要消息 / 解锁消息」——有锁定就清空，没有就锁最近一轮。
             const outcome = togglePin(deps, { agent });
@@ -541,6 +639,25 @@ export function registerHttp(webCtx, deps) {
             if (code === 'busy') {
               return send(res, 409, { ok: false, code, message: errorText(error) });
             }
+            // 0.5.2 L 项：强制归档失败要把**具体原因**带回界面（不静默、不吞成通用文案）。
+            // 0.5.3 P2-2：状态码由动作层标注（未知会话 404 / 宿主缺接缝 503 / 内部错 500），
+            // 不再一律 400。
+            if (code === 'force-archive') {
+              const status = Number.isInteger(error?.statusCode) ? error.statusCode : 400;
+              return send(res, status, {
+                ok: false,
+                code,
+                message: error instanceof Error ? error.message : String(error),
+              });
+            }
+            // 0.5.3 P2-2：recover 等动作层显式标注的状态码（404/503/500）直接映射。
+            if (Number.isInteger(error?.statusCode) && error.statusCode >= 400) {
+              return send(res, error.statusCode, {
+                ok: false,
+                ...(code === undefined ? {} : { code }),
+                message: error instanceof Error ? error.message : String(error),
+              });
+            }
             if (error?.statusCode === 413) {
               return send(res, 413, { ok: false, message: '请求体太大' });
             }