dsh-loop-continue 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## 0.1.1
+
+### Fixed
+
+- **Judge route leaked a literal `null` provider.** With `judgeProvider` absent
+  the guard tested `!== undefined`, so a `null` in the profile config was passed
+  straight to the LLM service as `{ provider: null, model: null }`. The service
+  reports an unknown provider through an error *finish chunk* rather than a
+  throw, so the call failed silently, the judge read an empty answer, and every
+  turn logged `verdict=false`. The guard now treats `null` and unset alike and
+  follows the conversation's own provider/model.
+- **A judge failure was invisible.** An error finish chunk is now surfaced as
+  `judge failed: ...` instead of being parsed as a `false` verdict.
+- **Steering could burn the whole per-turn budget on the same refusal.** The
+  guard now records the session-log position at each steer and checks whether
+  any step in between actually called a tool. A steer the model ignored ends the
+  turn instead of spending the remaining budget.
+
+### Changed
+
+- **Configuration is resolved per evaluation** rather than frozen at mount, so
+  a change reaches the next turn-stopping check without a restart.
+- **A Settings section is installed** (namespace `loop-continue`) for live
+  reconfiguration from the harness Settings UI.
+- `judgeProvider`/`judgeModel` at `null` or unset both mean "follow the
+  conversation's route"; the judge no longer derives a route from the global
+  default-model setting.
+
+## 0.1.0
+
+Initial release: continue a turn whose trailing text promised an action that no
+tool call performed.

package/README.md

@@ -18,9 +18,9 @@ more step; `false` (or an unparseable answer) lets the turn close.
 |------------------|---------|------------------------------------------------|
 | `maxContinuations` | 10    | hard cap on steering per turn (no infinite loop) |
 | `maxSteps`       | 10      | newest steps shown to the judge                |
-| `maxTailChars`   | 2000    | cap on the trailing assistant text             |
-| `judgeProvider`  | null    | override provider; null = follow session route |
-| `judgeModel`     | null    | override model; null = follow session route    |
+| `maxTailChars`   | 2000    | trailing-text budget split across the first and last halves |
+| `judgeProvider`  | null    | override provider; null/unset = derive from the active default model |
+| `judgeModel`     | null    | override model; null/unset = derive from the active default model    |
 | `judgeMaxTokens` | 64      | judge output cap                               |
 | `judgeTemperature` | 0     | judge sampling temperature                     |
 | `steerText`      | built-in | message that resumes the turn                |
@@ -35,3 +35,51 @@ No model call runs unless the turn *both*:
 
 This keeps the extra judge call off ordinary finished turns and only spends it
 where the model plausibly dropped a pending action.
+
+## Stopping early
+
+Steering is not free: each continuation costs a judge round-trip plus one more
+agent step. So the guard also watches whether a steer *worked*.
+
+When it steers, it records how far the session log had grown. The next time the
+same turn stops, it checks whether any assistant step in between actually called
+a tool. If the model only narrated again, the steer was ignored and the turn is
+closed instead of spending the remaining budget on the same refusal. A model
+that answers the steer with a real tool call keeps its normal budget.
+
+## Configuring the guard
+
+The guard resolves its config on every evaluation rather than freezing it at
+mount, so a change reaches the very next turn-stopping check. Two ways to set
+values:
+
+- the harness **Settings UI** (the plugin installs a `loop-continue` section), or
+- the profile's own `cordis.patch.yml`.
+
+Prefer leaving `judgeProvider`/`judgeModel` unset. The guard then derives a
+registered route from the active default model, which always resolves; a
+hand-written route can name a provider the LLM service does not have registered,
+and the judge call then fails.
+
+## Hot mount
+
+`cordis.patch.yml` ships a **plain insert** — only `id` + `name`, no `config`
+and no `!!js` expressions — so a market hot-mount can add or remove this plugin
+as a minimal row. No user-specific endpoint, provider, or key is baked into the
+patch: policy is resolved at runtime as described above.
+
+A patch-layer change is replayed in full on every reload
+(`applyEntryPatches` clones the entry list before applying), so a row adds and
+removes cleanly and never accumulates.
+
+Whether a patch edit takes effect *without a restart* depends on the host:
+
+- Under the CLI (`dsh profile`), `runProfile` installs an HMR service and
+  registers the profile and user patch files with it, so patch edits are applied
+  live.
+- Under **DSH Desktop 2.0.3** that path is not taken — the desktop shell
+  composes the profile itself (`dsh-app-boot` helpers) and never loads
+  `cordis-plugin-hmr`, so a `cordis.patch.yml` edit needs a profile restart.
+
+Edits to `lib/*.js` always need a restart: the dsh HMR service is created with
+`root: []`, so no source directory is watched for module replacement.

package/cordis.patch.yml

@@ -1,6 +1,15 @@
 # dsh bundle patch: inserts this plugin into a profile's layer stack.
-# Plain insert only (id + name), so hot-mount can activate it live.
-# Config lives in the profile's own cordis.patch.yml (or Settings UI).
+#
+# This is a PLAIN insert -- only `id` + `name`, no `config`, no `!!js`
+# expressions -- so the market's hot-mount parser can activate it live without
+# a profile restart. `applyEntryPatches` structuredClones the entry list and
+# replays the whole patch stack on every reload, so a minimal row adds and
+# removes cleanly.
+#
+# Policy is NOT frozen here. The guard resolves its config on every evaluation
+# (and accepts a live settings source), so values set in the profile's own
+# cordis.patch.yml or in the harness Settings UI apply to the next turn without
+# a restart.
 - insert:
     - id: loop-continue
       name: 'dsh-loop-continue'

package/lib/index.d.ts

@@ -17,11 +17,11 @@ export interface Config {
   maxContinuations?: number
   /** Newest steps shown to the judge. */
   maxSteps?: number
-  /** Cap on the trailing assistant text handed to the judge. */
+  /** Total trailing-text characters handed to the judge, split across the first and last halves. */
   maxTailChars?: number
-  /** Override provider; null = follow the session route. */
+  /** Override provider; null/unset derives from the active default model. */
   judgeProvider?: string | null
-  /** Override model; null = follow the session route. */
+  /** Override model; null/unset derives from the active default model. */
   judgeModel?: string | null
   /** Judge output cap. */
   judgeMaxTokens?: number
@@ -73,3 +73,6 @@ export declare function parseVerdict(text: string): boolean
 
 /** Register the turn-stopping guard on a Cordis context. */
 export declare function apply(ctx: unknown, config: Config): void
+
+/** Settings namespace carrying this plugin's policy; drives live reconfiguration. */
+export declare const SETTINGS_NAMESPACE: 'loop-continue'

package/lib/index.js

@@ -33,7 +33,7 @@ const DEFAULT_MAX_CONTINUATIONS = 10
 /** How many most-recent steps of the current turn the summary shows. */
 const DEFAULT_MAX_STEPS = 10
 
-/** Cap on the trailing assistant text handed to the judge. */
+/** Total characters of trailing text handed to the judge, split across the first and last halves. */
 const DEFAULT_MAX_TAIL_CHARS = 2000
 
 export const Config = z.object({
@@ -119,16 +119,40 @@ export function summarizeTurn(events, turn, maxSteps) {
     }
   }
 
-  // The user instruction that opened this turn is the nearest preceding
-  // human message; it anchors the judge's notion of "the task".
+  // The judge needs the task this turn is answering. Walk the preceding
+  // human turns in reverse, skipping bare acknowledgements ("continue",
+  // "ok", ...) that carry no task information, and keep the most recent few
+  // substantive requests in chronological order.
+  const acknowledgements = new Set([
+    '继续', '继续吧', '接着', '继续搞', '好的', '好', '嗯', '知道了',
+    'ok', 'okay', 'go on', 'continue', 'go', 'next',
+  ])
+  const isAcknowledgement = text => acknowledgements.has(text.trim().toLowerCase())
+  const requests = []
   for (let i = events.length - 1; i >= 0; i -= 1) {
     const event = events[i]
     if (event.type !== 'user/message' || event.data?.turn > turn) continue
-    const source = event.data.source
-    if (source?.kind !== 'user') continue
-    userRequest = (event.data.content ?? [])
-      .filter(b => b.type === 'text').map(b => b.text).join('\n')
-    break
+    if (event.data.source?.kind !== 'user') continue
+    const text = (event.data.content ?? [])
+      .filter(b => b.type === 'text').map(b => b.text).join('\n').trim()
+    if (!text) continue
+    if (isAcknowledgement(text)) continue
+    requests.unshift(text)
+    if (requests.length >= 3) break
+  }
+  // Fall back to the nearest human message when every preceding one is a bare
+  // acknowledgement (or there are none); a weak anchor beats a blank one.
+  if (requests.length === 0) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+      const event = events[i]
+      if (event.type !== 'user/message' || event.data?.turn > turn) continue
+      if (event.data.source?.kind !== 'user') continue
+      userRequest = (event.data.content ?? [])
+        .filter(b => b.type === 'text').map(b => b.text).join('\n').trim()
+      if (userRequest) break
+    }
+  } else {
+    userRequest = requests.join('\n')
   }
 
   const window = steps.slice(-maxSteps)
@@ -164,8 +188,13 @@ export function renderSummary(summary, maxTailChars) {
     const tools = s.tools.length > 0 ? s.tools.join(', ') : 'no tool call'
     return `  step ${s.step}: ${tools}`
   })
+  // The model states its *next* action near the front ("now I will..."),
+  // then often rambles; the very end usually re-commits. Keep both ends so
+  // the judge sees the promise without eating the whole budget.
   const tail = summary.text.length > maxTailChars
-    ? `${summary.text.slice(-maxTailChars)}`
+    ? `${summary.text.slice(0, Math.floor(maxTailChars / 2))}\n`
+      + '...\n[truncated middle]\n...\n'
+      + `${summary.text.slice(-Math.ceil(maxTailChars / 2))}`
     : summary.text
   const priorNote = summary.truncated
     ? `  (showing only the last ${summary.steps.length} steps)\n`
@@ -210,8 +239,12 @@ async function judge(ctx, route, summary, config, signal) {
     'A turn ends when the agent writes text and calls no tool.',
     'Decide whether that trailing text states an action the agent still',
     'intends to perform, or merely reports completed work.',
-    'A promise of future action ("now I will...", "next I will...") that no',
-    'tool call in the step list performed means the task is unfinished.',
+    'A promise of future action means the task is unfinished when no tool',
+    'call in the step list performed it. This includes explicit "now I will...",',
+    '"next I will..." as well as softer commitments like "let me check/confirm',
+    '/verify ... then ...", "I need to look at ...", "let me first ...", or',
+    'phrases that name a pending read, edit, run, or lookup the agent has not',
+    'yet performed.',
     'A finished report, a question to the human, or a final answer means the',
     'task is finished.',
     'Reply with exactly one word: true or false.',
@@ -237,6 +270,14 @@ async function judge(ctx, route, summary, config, signal) {
 
   const text = assembler.blocks()
     .filter(b => b.type === 'text').map(b => b.text).join('')
+  // A missing or unknown provider is swallowed into an error finish chunk by
+  // the LLM service; surface it so a misconfigured judge route is visible in
+  // the log instead of reading as an endless stream of `verdict=false`.
+  const finish = assembler.finish
+  if (finish?.kind === 'error') {
+    const detail = finish.failure?.message ?? JSON.stringify(finish.failure ?? {})
+    throw new Error(`judge call failed: ${detail}`)
+  }
   return parseVerdict(text)
 }
 
@@ -246,26 +287,15 @@ async function judge(ctx, route, summary, config, signal) {
  * @param config - plugin policy.
  */
 export function apply(ctx, config) {
-  const maxContinuations = config.maxContinuations ?? DEFAULT_MAX_CONTINUATIONS
-  const maxSteps = config.maxSteps ?? DEFAULT_MAX_STEPS
-  const maxTailChars = config.maxTailChars ?? DEFAULT_MAX_TAIL_CHARS
-  const resolved = {
-    ...config,
-    maxContinuations,
-    maxSteps,
-    maxTailChars,
-    judgeMaxTokens: config.judgeMaxTokens ?? 64,
-    judgeTemperature: config.judgeTemperature ?? 0,
-    steerText: config.steerText ?? (
-      'You described an action but did not call any tool. Continue the task now: '
-      + 'call the tool for the action you just described. Do not narrate — emit the tool call.'
-    ),
-    debug: config.debug ?? false,
-  }
+  // The live config source. A Settings-UI change swaps this closure instead of
+  // rebuilding the plugin, so every evaluation below reads the current values.
+  let current = () => config
+  registerSettings(ctx, config, { setSource: source => { current = source } })
 
-  ctx.logger?.info?.(`[${name}] loaded: maxContinuations=${resolved.maxContinuations} `
-    + `maxSteps=${resolved.maxSteps} judge=${resolved.judgeProvider ?? '<session-route>'}`
-    + `/${resolved.judgeModel ?? '<session-route>'} debug=${String(resolved.debug)}`)
+  const initial = resolveConfig(current())
+  ctx.logger?.info?.(`[${name}] loaded: maxContinuations=${initial.maxContinuations} `
+    + `maxSteps=${initial.maxSteps} judge=${initial.judgeProvider ?? '<session-route>'}`
+    + `/${initial.judgeModel ?? '<session-route>'} debug=${String(initial.debug)}`)
 
   /**
    * Continuations already spent per turn. The turn number is stable while
@@ -274,7 +304,16 @@ export function apply(ctx, config) {
    */
   const spent = new Map()
 
+  /**
+   * Turns waiting to see whether their last steer changed anything. A steer
+   * that the model ignores costs a full judge round-trip and produces another
+   * narration, so one ignored steer ends the turn instead of burning the whole
+   * budget. Cleared as soon as the probe is read, or when the turn closes.
+   */
+  const pendingProbe = new Map()
+
   ctx.on('agent/turn-stopping', async ({ agent, turn, signal }) => {
+    const resolved = resolveConfig(current())
     const used = spent.get(turn) ?? 0
     if (used >= resolved.maxContinuations) {
       // Keep the exhausted entry: the hook fires again after every extra step
@@ -283,10 +322,31 @@ export function apply(ctx, config) {
       return
     }
 
-    const summary = summarizeTurn(readEvents(agent.session), turn, resolved.maxSteps)
+    const events = readEvents(agent.session)
+    const summary = summarizeTurn(events, turn, resolved.maxSteps)
     if (!looksUnfinished(summary)) return
 
-    const route = resolved.judgeProvider !== undefined && resolved.judgeModel !== undefined
+    // Did the previous steer actually make the model call a tool? A turn that
+    // narrates again after being told to emit the call will keep doing so, so
+    // stop here rather than spend the remaining budget on the same refusal.
+    const probe = pendingProbe.get(turn)
+    if (probe !== undefined) {
+      pendingProbe.delete(turn)
+      const calledTool = events.slice(probe.eventsAtSteer).some(event => {
+        if (event.type !== 'assistant/message' || event.data?.turn !== turn) return false
+        return (event.data.message?.content ?? []).some(b => b.type === 'tool-call')
+      })
+      if (!calledTool) {
+        spent.set(turn, resolved.maxContinuations)
+        if (resolved.debug) {
+          ctx.logger?.info?.(`[${name}] turn ${turn}: previous steer produced no tool call; `
+            + 'stopping instead of steering again')
+        }
+        return
+      }
+    }
+
+    const route = resolved.judgeProvider != null && resolved.judgeModel != null
       ? { provider: resolved.judgeProvider, model: resolved.judgeModel }
       : routeOf(agent)
 
@@ -309,6 +369,7 @@ export function apply(ctx, config) {
     }
 
     spent.set(turn, used + 1)
+    pendingProbe.set(turn, { eventsAtSteer: events.length })
     agent.steer(createUserMessage({
       content: [{ type: 'text', text: resolved.steerText }],
       source: PLUGIN_SOURCE,
@@ -317,15 +378,90 @@ export function apply(ctx, config) {
 
   /** Drop bookkeeping once a turn truly closes. */
   ctx.on('session/event', (_session, event) => {
-    if (event.type === 'turn/end') spent.delete(event.data.turn)
+    if (event.type === 'turn/end') {
+      spent.delete(event.data.turn)
+      pendingProbe.delete(event.data.turn)
+    }
   })
 }
 
-/** Read the turn's effective provider/model from the session request header. */
+/**
+ * Resolve one config snapshot.
+ *
+ * Called per evaluation rather than once at mount so a Settings-UI or patch
+ * change takes effect on the next turn-stopping hook without a restart.
+ *
+ * @param config - raw plugin config from the loader or the Settings section.
+ * @returns the config with every default applied.
+ */
+function resolveConfig(config) {
+  return {
+    ...config,
+    maxContinuations: config.maxContinuations ?? DEFAULT_MAX_CONTINUATIONS,
+    maxSteps: config.maxSteps ?? DEFAULT_MAX_STEPS,
+    maxTailChars: config.maxTailChars ?? DEFAULT_MAX_TAIL_CHARS,
+    judgeMaxTokens: config.judgeMaxTokens ?? 64,
+    judgeTemperature: config.judgeTemperature ?? 0,
+    steerText: config.steerText ?? (
+      'You described an action but did not call any tool. Continue the task now: '
+      + 'call the tool for the action you just described. Do not narrate — emit the tool call.'
+    ),
+    debug: config.debug ?? false,
+  }
+}
+
+/** Settings namespace so the harness Settings UI can drive this plugin live. */
+export const SETTINGS_NAMESPACE = 'loop-continue'
+
+/**
+ * Mount the plugin's Settings section.
+ *
+ * Registration is cosmetic: the guard works from the loader config even when
+ * no settings service is present. On a new core the section is installed
+ * through this plugin's own injector scope, so it lives for exactly this
+ * plugin's lifetime and disappears with it; on an older core the top-level
+ * helper is imported lazily, because the symbol only exists there.
+ *
+ * @param ctx - plugin context.
+ * @param config - base config used until a settings source replaces it.
+ * @param hooks - `setSource` receives the live settings-backed getter.
+ */
+function registerSettings(ctx, config, hooks) {
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['settings'], (settingsCtx) => {
+      const provider = settingsCtx?.settings
+      if (provider !== undefined && typeof provider.installSection === 'function') {
+        provider.installSection(ctx, SETTINGS_NAMESPACE, Config, config, hooks)
+      }
+    })
+    return
+  }
+  import('@deepseek-ai/dsh-settings').then(mod => {
+    if (typeof mod.installSettingsSection === 'function') {
+      mod.installSettingsSection(ctx, SETTINGS_NAMESPACE, Config, config, hooks)
+    }
+  }).catch(() => {
+    // Settings registration is cosmetic: the guard still works from the
+    // loader config when the section could not be mounted.
+  })
+}
+
+/**
+ * Resolve the provider/model the judge should call.
+ *
+ * The judge follows the model the current conversation is actually running:
+ * the turn is stopping right now, so that route is by definition working. No
+ * fallback and no derivation — a route that cannot be read is a real fault and
+ * must surface instead of being papered over with a different model.
+ *
+ * @param agent - the turn's agent subject.
+ * @returns the conversation's own provider/model route.
+ */
 function routeOf(agent) {
   const config = agent.session.requestHeader()?.config
-  if (config === undefined) {
-    throw new Error(`[${name}] no request header yet; set judgeProvider/judgeModel explicitly`)
+  if (config?.provider !== undefined && config?.model !== undefined) {
+    return { provider: config.provider, model: config.model }
   }
-  return { provider: config.provider, model: config.model }
+  throw new Error(`[${name}] the session has no request header yet; `
+    + 'set judgeProvider/judgeModel explicitly')
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-loop-continue",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Continue a DeepSeek Harness agent turn when the model narrated but did not call a tool.",
   "type": "module",
   "main": "lib/index.js",
@@ -11,14 +11,25 @@
     },
     "./package.json": "./package.json"
   },
-  "files": ["lib/index.js", "lib/index.d.ts", "cordis.patch.yml", "README.md"],
+  "files": [
+    "lib/index.js",
+    "lib/index.d.ts",
+    "cordis.patch.yml",
+    "CHANGELOG.md",
+    "README.md"
+  ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yunxiyang/dsh-loop-continue.git"
+  },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-session": "^0.1.1-rc.2"
   },
   "dsh": {