@xmanrui/dsh-im 4.34.2 → 4.35.1

package/src/channels/shared/harness-client.mjs

@@ -242,10 +242,12 @@ function turnStoppedError() {
   return error;
 }
 
-function workspacePaths(value) {
+function workspaceEntries(value) {
   if (!Array.isArray(value?.items)) return [];
   return value.items.flatMap((item) => (
-    typeof item?.path === 'string' && isAbsolute(item.path) ? [item.path] : []
+    typeof item?.path === 'string' && isAbsolute(item.path)
+      ? [{ path: item.path, title: typeof item.title === 'string' ? item.title : '' }]
+      : []
   ));
 }
 
@@ -378,6 +380,11 @@ export class AssistantTextAccumulator {
   #steps = new Map();
   #legacyText = '';
 
+  clear() {
+    this.#steps.clear();
+    this.#legacyText = '';
+  }
+
   appendDelta(step, index, text) {
     if (typeof text !== 'string' || !text) return;
     const stepNumber = Number.isSafeInteger(step) ? step : 0;
@@ -413,6 +420,22 @@ export class AssistantTextAccumulator {
   }
 }
 
+/** Keep answer text after the last tool boundary, shared by live and recovered replies. */
+export function accumulateFinalAssistantText(accumulator, event) {
+  if (event.type === 'tool/call') {
+    accumulator.clear();
+  } else if (event.type === 'assistant/chunk' && event.data?.chunk?.type === 'text-delta') {
+    accumulator.appendDelta(event.data.step, event.data.chunk.index, event.data.chunk.text);
+  } else if (event.type === 'assistant/message') {
+    const content = event.data?.message?.content;
+    const text = textFromHarnessContent(content);
+    // Canonical tool messages can arrive before or after the separate call.
+    // An explicitly empty final message must not revive an earlier preamble.
+    if (!text || content.some((part) => part?.type === 'tool-call')) accumulator.clear();
+    else accumulator.setCanonical(event.data.step, text);
+  }
+}
+
 function nonEmptyText(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
@@ -536,6 +559,7 @@ export class HarnessReplyTracker {
   #openTurn = null;
   #targetTurn = null;
   #assistantText = new AssistantTextAccumulator();
+  #finalAssistantText = null;
   #latestText = '';
   #finished = false;
   #reason = null;
@@ -546,13 +570,14 @@ export class HarnessReplyTracker {
   #pendingReasoningChars = 0;
   #reasoning = false;
 
-  constructor({ promptRpcId, afterSeq = -1, reasoning = false }) {
+  constructor({ promptRpcId, afterSeq = -1, reasoning = false, finalAnswerOnly = false }) {
     this.#promptRpcId = promptRpcId;
     this.#lastSeq = afterSeq;
     // Reasoning updates are opt-in per consumer: only channels that surface
     // thinking traces (Telegram thinking mode) subscribe; every other channel
     // keeps its pre-thinking-traces update stream untouched.
     this.#reasoning = reasoning === true;
+    if (finalAnswerOnly === true) this.#finalAssistantText = new AssistantTextAccumulator();
   }
 
   get finished() {
@@ -568,6 +593,10 @@ export class HarnessReplyTracker {
     return this.#latestText.trim();
   }
 
+  get finalAnswer() {
+    return this.#finalAssistantText ? this.#finalAssistantText.text : this.answer;
+  }
+
   get reason() {
     return this.#reason;
   }
@@ -695,6 +724,8 @@ export class HarnessReplyTracker {
       }
       if (event.data?.turn !== this.#targetTurn) continue;
 
+      if (this.#finalAssistantText) accumulateFinalAssistantText(this.#finalAssistantText, event);
+
       if (event.type === 'assistant/chunk' && event.data?.chunk?.type === 'text-delta') {
         const step = event.data?.step ?? 0;
         const index = event.data.chunk.index ?? 0;
@@ -874,6 +905,14 @@ function harnessTurnSucceeded(reason) {
   return (nonEmptyText(reason?.kind) ?? nonEmptyText(reason)) === 'completed';
 }
 
+function sessionArchivedError(sessionId, cause) {
+  const error = new Error('The Session is archived and cannot process this message.', { cause });
+  error.code = 'session-archived';
+  error.promptAccepted = false;
+  error.details = { sessionId };
+  return error;
+}
+
 export class HarnessClient {
   #baseUrl;
   #apiProxy;
@@ -1081,8 +1120,12 @@ export class HarnessClient {
   }
 
   async listWorkspaces(options = {}) {
+    return (await this.listWorkspaceEntries(options)).map((item) => item.path);
+  }
+
+  async listWorkspaceEntries(options = {}) {
     await this.ensureRunning(options);
-    return workspacePaths(await this.rpc('workspace.list', {}, 30_000, options));
+    return workspaceEntries(await this.rpc('workspace.list', {}, 30_000, options));
   }
 
   async listWorkspaceSessions(workspacePath, options = {}) {
@@ -1259,11 +1302,47 @@ export class HarnessClient {
     }, timeoutMs, options);
   }
 
+  async #isSessionArchived(sessionId, options = {}) {
+    const value = await this.rpc('workspace.list', {}, 30_000, options);
+    if (!Array.isArray(value?.archivedSessionIds)
+      || value.archivedSessionIds.some((id) => typeof id !== 'string' || !id)) {
+      throw new HarnessTransportError('harness-response-invalid', 'workspace.list');
+    }
+    return value.archivedSessionIds.includes(sessionId);
+  }
+
+  // A diagnostic recheck must not hide the original failure or cancellation.
+  async #confirmedArchiveError(sessionId, options, cause) {
+    try {
+      if (await this.#isSessionArchived(sessionId, options)) return sessionArchivedError(sessionId, cause);
+    } catch (error) {
+      if (options?.signal?.aborted) throw options.signal.reason ?? error;
+    }
+    return null;
+  }
+
+  async #sessionRpc(method, payload, timeoutMs, options) {
+    try {
+      return await this.rpc(method, payload, timeoutMs, options);
+    } catch (error) {
+      if (options?.signal?.aborted) throw options.signal.reason ?? error;
+      if (error instanceof HarnessRpcError
+        && ['internal', 'gateway/internal', 'session-not-found', 'session/not-found'].includes(error.code)) {
+        throw await this.#confirmedArchiveError(payload.sessionId, { signal: options?.signal }, error) ?? error;
+      }
+      throw error;
+    }
+  }
+
   async sessionExists(sessionId, options = {}) {
+    // Archived Sessions still exist. Returning false here would silently bind
+    // the conversation to a new Session; reading their active log can also fail.
+    if (await this.#isSessionArchived(sessionId, options)) return true;
     try {
-      await this.rpc('session.history', { sessionId, maxMessages: 1 }, 30_000, options);
+      await this.#sessionRpc('session.history', { sessionId, maxMessages: 1 }, 30_000, options);
       return true;
     } catch (error) {
+      if (error.code === 'session-archived') return true;
       if (error instanceof HarnessRpcError && error.code === 'session-not-found') return false;
       throw error;
     }
@@ -1635,7 +1714,8 @@ export class HarnessClient {
     const inboundFiles = Array.isArray(options.files) ? options.files.filter(Boolean) : [];
     const inboundImages = Array.isArray(options.images) ? options.images.filter(Boolean) : [];
     await this.ensureRunning({ signal });
-    const before = await this.rpc(
+    if (await this.#isSessionArchived(sessionId, { signal })) throw sessionArchivedError(sessionId);
+    const before = await this.#sessionRpc(
       'session.history',
       { sessionId, maxMessages: 1 },
       30_000,
@@ -1644,7 +1724,10 @@ export class HarnessClient {
     const baselineSeq = Math.max(-1, ...(before.events ?? []).map(({ event }) => event.seq ?? -1));
     const promptRpcId = `${this.#rpcIdPrefix}-${randomUUID()}`;
     const releasePromptInputOrigin = registerImInputOrigin(this.#interactionRegistry, promptRpcId);
-    const tracker = new HarnessReplyTracker({ promptRpcId, afterSeq: baselineSeq, reasoning });
+    const tracker = new HarnessReplyTracker({
+      promptRpcId, afterSeq: baselineSeq, reasoning, finalAnswerOnly: options.finalAnswerOnly,
+    });
+    let checkedBlockedSeq = baselineSeq;
     let lastProgressAt = Date.now();
     let lastPollSeq = tracker.lastSeq;
     let progressTail = Promise.resolve();
@@ -1802,7 +1885,7 @@ export class HarnessClient {
       // message that merely looks like a guidance block is not configuration.
       imSourceGuidance.publish(sessionId, options.sourceGuidance);
       const clientTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-      const sendPrompt = (promptContent) => this.rpc('session.prompt', {
+      const sendPrompt = (promptContent) => this.#sessionRpc('session.prompt', {
         sessionId,
         mode: 'queue',
         content: promptContent,
@@ -1856,7 +1939,7 @@ export class HarnessClient {
         // active until turn/end and can therefore outlive a stalled turn.
         while (true) {
           await sleep(300, signal);
-          const history = await this.rpc(
+          const history = await this.#sessionRpc(
             'session.history',
             { sessionId, maxMessages: 50 },
             30_000,
@@ -1871,16 +1954,19 @@ export class HarnessClient {
           if (tracker.finished) {
             turnFinished = true;
             if (!ownership?.stopRequested && !harnessTurnSucceeded(tracker.reason)) {
-              throw harnessTurnError(tracker.reason);
+              const failure = harnessTurnError(tracker.reason);
+              if (failure.code === 'turn-blocked') {
+                throw await this.#confirmedArchiveError(sessionId, { signal }, failure) ?? failure;
+              }
+              throw failure;
             }
             // An accepted /stop revokes attachment delivery even when Harness
             // preserved a useful partial text answer for the existing UX.
             const artifactCount = ownership?.stopRequested
               ? 0
               : await deliverArtifacts();
-            if (tracker.answer) {
-              return tracker.answer;
-            }
+            const answer = ownership?.stopRequested ? tracker.answer : tracker.finalAnswer;
+            if (answer) return answer;
             if (artifactCount > 0) return '';
             if (ownership?.stopRequested) throw turnStoppedError();
             if (artifactHandoffError) throw artifactHandoffError;
@@ -1892,8 +1978,30 @@ export class HarnessClient {
             throw harnessTurnError(tracker.reason);
           }
 
+          if (tracker.turn === null && !ownership?.stopRequested) {
+            // An admission gate can block before user/message supplies rpcId.
+            // This event only prompts a Session-level archive check; it never
+            // grants ownership of another caller's turn, artifacts or approvals.
+            const blockedSeq = Math.max(checkedBlockedSeq, ...(history.events ?? [])
+              .map((entry) => entry?.event ?? entry)
+              .filter((event) => event?.type === 'turn/end'
+                && (event.data?.reason?.kind ?? event.data?.reason) === 'blocked'
+                && Number.isSafeInteger(event.seq))
+              .map((event) => event.seq));
+            if (blockedSeq > checkedBlockedSeq) {
+              checkedBlockedSeq = blockedSeq;
+              const archived = await this.#confirmedArchiveError(sessionId, { signal });
+              if (archived) throw archived;
+            }
+          }
+
           if (Date.now() - lastProgressAt < timeoutMs) continue;
 
+          if (!ownership?.stopRequested) {
+            const archived = await this.#confirmedArchiveError(sessionId, { signal });
+            if (archived) throw archived;
+          }
+
           let running = false;
           try {
             running = await this.isSessionRunning(sessionId, { signal });
@@ -1911,6 +2019,10 @@ export class HarnessClient {
           throw timeoutError;
         }
       } catch (error) {
+        if (error.code === 'session-archived') {
+          error.promptAccepted = promptAccepted;
+          error.details = { ...error.details, promptRpcId, baselineSeq, turn: tracker.turn, lastSeq: tracker.lastSeq };
+        }
         if (error instanceof HarnessTurnError) {
           error.details ??= {
             sessionId, promptRpcId, baselineSeq, turn: tracker.turn, lastSeq: tracker.lastSeq,

package/src/channels/shared/i18n-en/shared-a.mjs

@@ -78,8 +78,12 @@ export default {
     'The model rejected the current content. Revise the request and try again.',
   '模型达到输出长度上限，但没有生成可显示的结果。请缩小任务范围后重试。':
     'The model reached its output limit without producing a displayable result. Reduce the task scope and try again.',
-  '任务正在等待无法在当前渠道完成的操作。请在 DeepSeek Harness 中处理后再试。':
-    'The task is waiting for an action that cannot be completed in this channel. Handle it in DeepSeek Harness, then try again.',
+  '本轮处理被阻止，未能完成。请在 DSH 中查看会话状态和相关提示。':
+    'This turn was blocked and did not finish. Check the Session status and related notices in DSH.',
+  '当前会话已归档，无法继续处理。请在 DSH 中取消归档，或发送 /new 创建新会话。':
+    'The current Session is archived and cannot continue. Unarchive it in DSH, or send /new to create a new Session.',
+  '本条消息可能仍在会话队列中，请先到 DSH 查看状态，避免重复提交。':
+    'This message may still be queued in the Session. Check its status in DSH before submitting it again.',
   '任务被意外中断，本次未完成。请重试。':
     'The task was unexpectedly interrupted and did not finish. Please try again.',
   '当前会话已不存在。请发送 /new 创建新会话后重试。':

package/src/channels/shared/message-failure.mjs

@@ -67,11 +67,13 @@ const FAILURE_MESSAGES = Object.freeze({
   MODEL_OUTPUT_LIMIT:
     '模型达到输出长度上限，但没有生成可显示的结果。请缩小任务范围后重试。',
   TURN_BLOCKED:
-    '任务正在等待无法在当前渠道完成的操作。请在 DeepSeek Harness 中处理后再试。',
+    '本轮处理被阻止，未能完成。请在 DSH 中查看会话状态和相关提示。',
   TURN_INTERRUPTED:
     '任务被意外中断，本次未完成。请重试。',
   SESSION_NOT_FOUND:
     '当前会话已不存在。请发送 /new 创建新会话后重试。',
+  SESSION_ARCHIVED:
+    '当前会话已归档，无法继续处理。请在 DSH 中取消归档，或发送 /new 创建新会话。',
   SESSION_BUSY:
     '当前会话仍在处理上一项任务。请等待完成，或发送 /stop 后重试。',
   SESSION_STALE:
@@ -137,6 +139,7 @@ function failureCode(error) {
   if (code === 'turn-blocked') return 'TURN_BLOCKED';
   if (['turn-interrupted', 'turn-aborted'].includes(code)) return 'TURN_INTERRUPTED';
   if (code === 'session-not-found') return 'SESSION_NOT_FOUND';
+  if (code === 'session-archived') return 'SESSION_ARCHIVED';
   if (code === 'agent-busy') return 'SESSION_BUSY';
   if (code === 'workspace-session-stale') return 'SESSION_STALE';
   if (code.startsWith('workspace-')) return 'WORKSPACE_UNAVAILABLE';
@@ -220,7 +223,8 @@ export function classifyMessageFailure(error, {
     reason: safeReason ?? safeFailureReason(error?.code) ?? code,
     message: typeof userMessage === 'string' && userMessage.trim()
       ? userMessage.trim()
-      : t(FAILURE_MESSAGES[code]),
+      : t(FAILURE_MESSAGES[code]) + (code === 'SESSION_ARCHIVED' && error?.promptAccepted === true
+        ? `\n${t('本条消息可能仍在会话队列中，请先到 DSH 查看状态，避免重复提交。')}` : ''),
     referenceId: safeReferenceId(referenceId),
     at: Number.isFinite(at) ? at : Date.now(),
   });

package/src/channels/shared/workspace-command.mjs

@@ -62,17 +62,19 @@ export function parseSessionListArgument(value) {
   return { selector: '', limit };
 }
 
+async function existingWorkspacePath(value) {
+  const workspace = normalizedWorkspacePath(value);
+  if (!workspace) return null;
+  try {
+    if (!(await stat(workspace)).isDirectory()) return null;
+    return normalizedWorkspacePath(await realpath(workspace));
+  } catch {
+    return null;
+  }
+}
+
 async function existingWorkspacePaths(values) {
-  const checked = await Promise.all(values.map(async (value) => {
-    const workspace = normalizedWorkspacePath(value);
-    if (!workspace) return null;
-    try {
-      if (!(await stat(workspace)).isDirectory()) return null;
-      return normalizedWorkspacePath(await realpath(workspace));
-    } catch {
-      return null;
-    }
-  }));
+  const checked = await Promise.all(values.map(existingWorkspacePath));
   return [...new Set(checked.filter(Boolean))];
 }
 
@@ -109,16 +111,26 @@ async function selectedWorkspacePath(value) {
   }
 }
 
-export async function workspacePathSnapshot(harness, options = {}) {
-  const listed = await harness.listWorkspaces(options);
+export async function workspacePathSnapshot(harness, { includeTitles = false, ...options } = {}) {
+  const withEntries = includeTitles && typeof harness.listWorkspaceEntries === 'function';
+  const listed = await (withEntries ? harness.listWorkspaceEntries(options) : harness.listWorkspaces(options));
   const currentValue = typeof harness?.currentWorkspace === 'function'
     ? harness.currentWorkspace()
     : null;
-  const [current] = currentValue ? await existingWorkspacePaths([currentValue]) : [];
-  const registered = await existingWorkspacePaths(Array.isArray(listed) ? listed : []);
-  const paths = [...new Set([...(current ? [current] : []), ...registered])];
+  const current = await existingWorkspacePath(currentValue);
+  const entries = await Promise.all((Array.isArray(listed) ? listed : []).map(async (item) => ({
+    path: await existingWorkspacePath(withEntries ? item?.path : item),
+    title: withEntries ? safeDisplayText(item?.title) : '',
+  })));
+  const paths = [...new Set([...(current ? [current] : []), ...entries.map((item) => item.path).filter(Boolean)])];
+  const titles = {};
+  if (includeTitles) {
+    for (const item of entries) {
+      if (item.path && item.title && !titles[item.path]) titles[item.path] = item.title;
+    }
+  }
   harness.assertWorkspaceScope?.();
-  return { current: current ?? null, paths };
+  return { current: current ?? null, paths, ...(includeTitles ? { titles } : {}) };
 }
 
 export function splitWorkspaceCommandMessage(message) {