dsh-autorestart 0.3.0 → 0.3.2

package/README.md

@@ -7,7 +7,7 @@ Restart DeepSeek Harness without losing the work that is currently running.
 [![dsh-plugin](https://img.shields.io/github/topics/dsh-plugin?style=flat-square)](https://github.com/topics/dsh-plugin)
 [![language](https://img.shields.io/badge/language-JavaScript-yellow?style=flat-square)](https://github.com/Eason-22/dsh-autorestart)
 
-Chinese version: [README.zh.md](README.zh.md)
+Chinese version: [README.zh.md](docs/README.zh.md)
 
 ## What it does
 

package/index.js

@@ -150,11 +150,13 @@ function delay(ms) {
 }
 
 /**
- * Hard dependencies. `sessionController` is read optionally (`ctx.get`) so the plugin
- * also loads in compositions without the web session controller; it simply cannot
- * resume agents there.
+ * Hard dependencies. `sessionController` is declared as a dependency because a
+ * session that is NOT live in this process can only be resumed through it
+ * (`resolveAgent`) or, as a fallback, through `prompt` (which resumes the cold
+ * session and admits the message in one step). It is still looked up
+ * defensively so a composition that provides it late still resumes.
  */
-export const inject = ['agents', 'goals', 'tools', 'timer', 'systemPrompt']
+export const inject = ['agents', 'goals', 'tools', 'timer', 'systemPrompt', 'sessionController']
 
 /**
  * Validated loader row config. Exported so the Plugin Manager / config editor can show
@@ -1268,6 +1270,7 @@ function createRuntime(ctx, config) {
     goalFor,
     handoffRecord: (sessionId) => handoffRecord(state, sessionId),
     overflowFor,
+    readSession,
     handoff,
     boot,
     /**
@@ -1279,10 +1282,30 @@ function createRuntime(ctx, config) {
      * Every attempt reports its own action/detail, exactly like the boot pass.
      *
      * @param {string} [sessionId] one session, or every pending session
+     * @param {{ force?: boolean }} [options] `force` re-opens one explicit session
+     *   (clearing a stale over-limit record and the attempt counter) before retrying
      * @returns {Promise<object[]>} one outcome per attempted session
      */
-    async recoverNow(sessionId) {
+    async recoverNow(sessionId, { force = false } = {}) {
       const target = typeof sessionId === 'string' && sessionId.trim() !== '' ? sessionId.trim() : null
+      if (force === true && target !== null) {
+        const entry = state.sessions && state.sessions[target] ? state.sessions[target] : null
+        if (entry) {
+          // An explicit retry re-checks the live evidence, so a stale record must
+          // not keep the session out of recovery, and the attempt counter resets.
+          entry.pendingResume = true
+          entry.interrupted = true
+          entry.pendingSince = Date.now()
+          entry.resumeAttempts = 0
+          entry.lastResumeError = null
+          setContextOverflow(state, target, { over: false })
+          // Clear the durable "never resume again" marker directly: calling the
+          // handoff writer here would CREATE one (and clear pendingResume again).
+          entry.handoff = null
+          runtime.persist()
+          log.info(`forced recovery for ${target}: cleared stale over-limit/handoff marks and the attempt counter`)
+        }
+      }
       const pending = recoverableSessions(state, {}).filter((entry) => (
         target === null ? true : String(entry.sessionId) === target
       ))
@@ -1410,8 +1433,30 @@ async function recoverSession(ctx, runtime, entry, config) {
   const recordedOverflow = entry.contextOverflow && entry.contextOverflow.over === true
     ? entry.contextOverflow
     : null
+  // The LIVE session is authoritative. A record is only a fallback for a session
+  // this process cannot read at all; a record whose evidence no longer holds (for
+  // example a false positive from an older detector) is cleared instead of
+  // keeping the session out of recovery forever.
+  let liveReadable = false
+  try {
+    const read = runtime.readSession(sessionId)
+    liveReadable = Boolean(read && read.session)
+  } catch {
+    liveReadable = false
+  }
   let overflow = null
-  if (recordedOverflow !== null) {
+  if (liveReadable) {
+    try {
+      overflow = runtime.overflowFor(sessionId)
+    } catch {
+      overflow = null
+    }
+    if ((!overflow || overflow.over !== true) && recordedOverflow !== null) {
+      setContextOverflow(state, sessionId, { over: false })
+      runtime.persist()
+      log.info(`cleared a stale over-limit record for ${sessionId}: the live session is not over the window`)
+    }
+  } else if (recordedOverflow !== null) {
     overflow = {
       over: true,
       inputTokens: Number.isFinite(recordedOverflow.inputTokens) ? recordedOverflow.inputTokens : null,
@@ -1420,12 +1465,6 @@ async function recoverSession(ctx, runtime, entry, config) {
         ? recordedOverflow.detail
         : 'the session is over the model context window (recorded by an earlier recovery)',
     }
-  } else {
-    try {
-      overflow = runtime.overflowFor(sessionId)
-    } catch {
-      overflow = null
-    }
   }
   if (overflow && overflow.over === true) {
     const detail = typeof overflow.detail === 'string' && overflow.detail !== ''
@@ -1463,12 +1502,67 @@ async function recoverSession(ctx, runtime, entry, config) {
   }
 
   if (agent === undefined) {
-    const controller = ctx.get('sessionController')
-    if (!controller || typeof controller.resolveAgent !== 'function') {
-      log.warn('sessionController is unavailable; cannot resume', sessionId)
-      noteRecovery(state, sessionId, 'session-controller-unavailable', 'sessionController.resolveAgent is unavailable')
+    // Resolve the controller defensively: the declared dependency first, then the
+    // optional lookup (a late-provided service still resumes this way).
+    let controller = null
+    let controllerPath = 'none'
+    try {
+      if (ctx.sessionController && typeof ctx.sessionController === 'object') {
+        controller = ctx.sessionController
+        controllerPath = 'inject'
+      }
+    } catch {}
+    if (controller === null) {
+      try {
+        const viaGet = ctx.get('sessionController')
+        if (viaGet && typeof viaGet === 'object') {
+          controller = viaGet
+          controllerPath = 'get'
+        }
+      } catch {}
+    }
+    const canResolve = Boolean(controller) && typeof controller.resolveAgent === 'function'
+    const canPrompt = Boolean(controller) && typeof controller.prompt === 'function'
+
+    // Fallback: the controller prompt RESUMES a cold session and admits the
+    // message in one step, so it can replace resolveAgent + followup entirely.
+    if (!canResolve) {
+      if (canPrompt) {
+        const text = continuationPrompt(entry, {
+          reason: (Array.isArray(entry.reasons) && entry.reasons[entry.reasons.length - 1]) || 'host restart',
+          override: config.continuationText,
+        })
+        try {
+          await controller.prompt({
+            requestId: crypto.randomUUID(),
+            sessionId,
+            mode: 'queue',
+            content: [{ type: 'text', text }],
+          })
+          entry.pendingResume = false
+          entry.running = false
+          entry.interrupted = false
+          entry.lastResumeError = null
+          noteRecovery(state, sessionId, 'resume-via-prompt', `sessionController.prompt (${controllerPath})`)
+          runtime.persist()
+          log.info(`resumed ${sessionId} through sessionController.prompt (${controllerPath})`)
+          return { sessionId, action: 'resume-via-prompt', detail: `sessionController.prompt (${controllerPath})`, controllerPath }
+        } catch (error) {
+          const detail = describeError(error)
+          entry.lastResumeError = detail
+          noteRecovery(state, sessionId, 'prompt-failed', detail)
+          runtime.persist()
+          log.warn(`sessionController.prompt failed for ${sessionId}:`, detail)
+          return { sessionId, action: 'prompt-failed', detail, error: detail, controllerPath }
+        }
+      }
+      const detail = controller === null
+        ? 'the session controller is not reachable (neither the declared inject nor ctx.get returned it)'
+        : 'the session controller exposes neither resolveAgent nor prompt'
+      log.warn('sessionController is unavailable; cannot resume', sessionId, detail)
+      noteRecovery(state, sessionId, 'session-controller-unavailable', detail)
       runtime.persist()
-      return { sessionId, action: 'session-controller-unavailable', detail: 'sessionController.resolveAgent is unavailable' }
+      return { sessionId, action: 'session-controller-unavailable', detail, controllerPath }
     }
     // A freshly reloaded profile can expose the live agent a moment after the
     // state file was written, so a THROWN error is retried inside the same boot
@@ -1508,6 +1602,10 @@ async function recoverSession(ctx, runtime, entry, config) {
       return { sessionId, action: 'agent-not-live', detail: lastError, error: lastError }
     }
     agent = result && result.agent
+    if (agent) {
+      noteRecovery(state, sessionId, 'resume-via-resolve-agent', `sessionController.resolveAgent (${controllerPath})`)
+      runtime.persist()
+    }
   }
   if (!agent) {
     entry.lastResumeError = 'resolveAgent returned no agent'
@@ -2012,6 +2110,10 @@ function registerTools(ctx, runtime, config) {
       additionalProperties: false,
       properties: {
         sessionId: { type: 'string', description: 'Retry only this session (default: every pending session).' },
+        force: {
+          type: 'boolean',
+          description: 'Re-open this explicit session before retrying: clears a stale over-limit / handoff mark and resets the attempt counter.',
+        },
       },
     },
     output: textOutput(
@@ -2028,7 +2130,7 @@ function registerTools(ctx, runtime, config) {
     ),
     async execute(args = {}) {
       const requested = typeof args.sessionId === 'string' ? args.sessionId.trim() : ''
-      const results = await runtime.recoverNow(requested !== '' ? requested : undefined)
+      const results = await runtime.recoverNow(requested !== '' ? requested : undefined, { force: args.force === true })
       return { ok: true, results }
     },
   })
@@ -2527,7 +2629,7 @@ function buildRecoverRoute(ctx, runtime, config) {
       void readJsonBody(req).then(async (payload) => {
         const body = payload && typeof payload === 'object' ? payload : {}
         const sessionId = typeof body.sessionId === 'string' ? body.sessionId.trim() : ''
-        const results = await runtime.recoverNow(sessionId !== '' ? sessionId : undefined)
+        const results = await runtime.recoverNow(sessionId !== '' ? sessionId : undefined, { force: body.force === true })
         res.statusCode = 200
         res.setHeader('content-type', 'application/json; charset=utf-8')
         res.setHeader('cache-control', 'no-store')

package/lib/lifecycle.js

@@ -33,8 +33,12 @@ function isDoneEntry(entry) {
   // with the same "context window exceeds limit" error.
   if (isObject(entry.handoff)) return true;
   if (isObject(entry.contextOverflow) && entry.contextOverflow.over === true) return true;
-  const phase = isObject(entry.goal) && typeof entry.goal.phase === 'string' ? entry.goal.phase : null;
-  return phase === 'done' || phase === 'complete' || phase === 'completed';
+  // A COMPLETE / paused / blocked GOAL does not make the SESSION done: a turn that
+  // was interrupted still deserves its continuation message. Only the explicit
+  // `done` flag and the durable handoff / over-limit markers remove a session
+  // from the automatic resume path. (Treating a completed goal as done used to
+  // silently drop every restart continuation for those sessions.)
+  return false;
 }
 
 /**
@@ -654,37 +658,55 @@ export function contextOverflow({ messages = [], contextWindow = null, events =
   }
   const window = isFiniteNumber(contextWindow) && contextWindow > 0 ? contextWindow : null;
 
-  let failure = '';
-  const scan = (text) => {
-    if (failure !== '' || typeof text !== 'string' || text === '') return;
-    if (CONTEXT_WINDOW_PATTERN.test(text) && EXCEED_PATTERN.test(text)) failure = flattenText(text).slice(0, 200);
-  };
-  for (let i = list.length - 1; i >= 0 && failure === ''; i -= 1) scan(messageTextOf(list[i]));
-  const eventList = Array.isArray(events) ? events.slice(-20) : [];
-  for (let i = eventList.length - 1; i >= 0 && failure === ''; i -= 1) scan(eventTextOf(eventList[i]));
+  // Numbers are authoritative: when the last request's token usage and the model
+  // window are both known, they decide, and a mere MENTION of the phrase in a
+  // tool result or in a pasted log can never flip the verdict.
+  if (inputTokens !== null && window !== null) {
+    if (inputTokens > window) {
+      return {
+        over: true,
+        inputTokens,
+        contextWindow: window,
+        detail: `the last request used ${inputTokens} tokens, which exceeds the model context window of ${window}`,
+      };
+    }
+    return {
+      over: false,
+      inputTokens,
+      contextWindow: window,
+      detail: `used ${inputTokens} of ${window} tokens`,
+    };
+  }
 
-  const numbers = inputTokens !== null && window !== null
-    ? ` (used ${inputTokens} of ${window} tokens)`
-    : inputTokens !== null
-      ? ` (used ${inputTokens} tokens; window unknown)`
-      : '';
+  // Without numbers, only a STRUCTURED turn failure counts: a `turn/end` event
+  // whose reason is an error whose failure message says the context window was
+  // exceeded. Free text in ordinary messages is never evidence.
+  let failure = '';
+  for (const event of (Array.isArray(events) ? events : [])) {
+    if (!isObject(event) || event.type !== 'turn/end') continue;
+    const reason = event.data && event.data.reason;
+    if (!isObject(reason) || reason.kind !== 'error') continue;
+    const error = reason.error;
+    const message = error && typeof error.message === 'string' ? error.message : '';
+    if (message === '') continue;
+    if (CONTEXT_WINDOW_PATTERN.test(message) && EXCEED_PATTERN.test(message)) {
+      failure = flattenText(message).slice(0, 200);
+    }
+  }
 
   if (failure !== '') {
-    return { over: true, inputTokens, contextWindow: window, detail: `a recent turn failed with a context-window error${numbers}: ${failure}` };
-  }
-  if (inputTokens !== null && window !== null && inputTokens > window) {
     return {
       over: true,
       inputTokens,
       contextWindow: window,
-      detail: `the last request used ${inputTokens} tokens, which exceeds the model context window of ${window}`,
+      detail: `a turn failed with a context-window error: ${failure}`,
     };
   }
   return {
     over: false,
     inputTokens,
     contextWindow: window,
-    detail: inputTokens !== null && window !== null ? `used ${inputTokens} of ${window} tokens` : null,
+    detail: inputTokens !== null ? `used ${inputTokens} tokens (window unknown)` : null,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-autorestart",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "DeepSeek Harness plugin: restart without losing work. Waits until every conversation is idle, restarts the host, then automatically resumes the interrupted sessions. AI-generated, not human-reviewed: use with caution.",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "assets/*.png",
     "screenshots.json",
     "README.md",
-    "README.zh.md"
+    "docs/*.md"
   ],
   "dsh": {
     "bundle": {