typeclaw 0.37.2 → 0.37.3

package/README.md

@@ -1,10 +1,11 @@
 # TypeClaw
 
 <p align="center">
-  <img src="./docs/public/typeclaw.png" alt="TypeClaw logo" width="240" />
+  <img src="./docs/public/typeclaw-transparent.png" alt="TypeClaw logo" width="240" />
 </p>
 
-> The agent for perfectionists — crafted in every detail. It behaves in your team's chat and gets sharper the longer it runs. Sandboxed and self-managing.
+<h3 align="center">The agent for perfectionists</h3>
+<p align="center">Crafted in every detail – it behaves in your team's chat and<br />gets sharper the longer it runs. Sandboxed and self-managing.</p>
 
 ## Why?
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeclaw",
-  "version": "0.37.2",
+  "version": "0.37.3",
   "homepage": "https://github.com/typeclaw/typeclaw#readme",
   "bugs": {
     "url": "https://github.com/typeclaw/typeclaw/issues"

package/src/channels/continuation-willingness.ts

@@ -48,8 +48,20 @@ const EN_PHRASES: readonly string[] = [
   'looking into it now',
   'working on it now',
   'on it now',
+  "i'm on it",
   'give me a moment',
   'give me a sec',
+  // Parity additions for common first-person-future acks: "investigate / look up
+  // / pull up" are work-verb siblings of the "look into / dig in" entries above,
+  // and "lemme" is the contracted "let me" that chat models routinely emit.
+  "i'll investigate",
+  "i'll look it up",
+  "i'll pull that up",
+  "i'll pull it up",
+  'let me pull',
+  'lemme check',
+  'lemme look',
+  'lemme take a look',
 ]
 
 // Korean: -ㄹ게요 / -겠습니다 future-volitional endings on check/look/continue/
@@ -81,6 +93,27 @@ const KO_PHRASES: readonly string[] = [
   '잠시만요',
   '잠깐만요',
   '곧 알려',
+  // Bare first-person-volitional verb endings: the -ㄹ게요/-겠습니다 ending is
+  // self-directed regardless of the preceding adverb, so the "바로 …" prefix in
+  // the entries above is not load-bearing. "볼게요" alone (and "먼저/한번/지금 볼게요"
+  // by substring) is the exact production miss — the ack "…먼저 볼게요" did not
+  // match because only the "바로 볼게요" compound was listed. Common work verbs
+  // (검토/조회/찾아/알아/처리) in the same volitional form join here for parity with
+  // "확인/살펴" above; "볼게여" is the casual -여 variant seen in chat.
+  '볼게요',
+  '볼게여',
+  '확인할게여',
+  '검토할게요',
+  '검토해볼게요',
+  '검토하겠습니다',
+  '조회해볼게요',
+  '조회하겠습니다',
+  '찾아볼게요',
+  '찾아보겠습니다',
+  '알아볼게요',
+  '알아보겠습니다',
+  '처리할게요',
+  '처리하겠습니다',
 ]
 
 // The remaining languages mirror the precision-first selection above: every
@@ -106,6 +139,12 @@ const ES_PHRASES: readonly string[] = [
   'déjame comprobar',
   'déjame verificar',
   'déjame mirar',
+  'voy a echar un vistazo',
+  'déjame echar un vistazo',
+  'ahora lo reviso',
+  'ahora reviso',
+  'ahora lo verifico',
+  'ahora mismo lo reviso',
   'lo reviso enseguida',
   'lo verifico enseguida',
   'enseguida lo reviso',
@@ -123,10 +162,15 @@ const FR_PHRASES: readonly string[] = [
   'je vais poursuivre',
   'je vais voir',
   'je vais contrôler',
+  'je vais creuser',
+  'je vais jeter un œil',
   'laisse-moi vérifier',
   'laisse-moi regarder',
+  'laisse-moi jeter un œil',
   'je vérifie tout de suite',
   'je regarde tout de suite',
+  'je regarde ça tout de suite',
+  'je regarde ça',
   'un instant',
   'donne-moi un instant',
   'donne-moi une seconde',
@@ -137,12 +181,16 @@ const IT_PHRASES: readonly string[] = [
   'vado a controllare',
   'vado a verificare',
   'vado a guardare',
+  "vado a dare un'occhiata",
   'fammi controllare',
   'fammi verificare',
   'fammi guardare',
+  "fammi dare un'occhiata",
+  "do un'occhiata",
   'controllo subito',
   'verifico subito',
   'continuo subito',
+  'guardo subito',
   'un momento',
   'dammi un momento',
   'dammi un secondo',
@@ -156,9 +204,11 @@ const PT_PHRASES: readonly string[] = [
   'vou olhar',
   'vou continuar',
   'vou prosseguir',
+  'vou dar uma olhada',
   'deixa eu verificar',
   'deixa eu conferir',
   'deixa eu olhar',
+  'deixa eu dar uma olhada',
   'verifico já',
   'já verifico',
   'um momento',
@@ -175,8 +225,13 @@ const DE_PHRASES: readonly string[] = [
   'ich werde fortfahren',
   'lass mich prüfen',
   'lass mich nachsehen',
+  'lass mich schauen',
   'ich schaue gleich',
+  'ich schaue mir das an',
+  'ich schaue mir das mal an',
   'ich prüfe gleich',
+  'ich prüfe das gleich',
+  'ich sehe gleich nach',
   'gleich prüfen',
   'gleich überprüfen',
   'gleich nachsehen',
@@ -194,6 +249,8 @@ const RU_PHRASES: readonly string[] = [
   'я продолжу',
   'продолжу проверку',
   'сейчас посмотрю',
+  'дай мне проверить',
+  'дайте мне проверить',
   'дайте мне минуту',
   'одну секунду',
   'минутку',
@@ -214,6 +271,10 @@ const ZH_PHRASES: readonly string[] = [
   '我马上确认',
   '我马上检查',
   '我马上看',
+  '让我看看',
+  '让我查一下',
+  '让我确认一下',
+  '让我检查一下',
   '稍等一下',
   '我看一下',
 ]
@@ -265,6 +326,9 @@ const TR_PHRASES: readonly string[] = [
   'kontrol edeceğim',
   'kontrol ediyorum',
   'bakacağım',
+  'bir bakayım',
+  'bir kontrol edeyim',
+  'kontrol edeyim',
   'inceleyeceğim',
   'devam edeceğim',
   'hemen kontrol ediyorum',

package/src/channels/router.ts

@@ -279,6 +279,27 @@ export const WILLINGNESS_NUDGE = [
   '',
   '---',
 ].join('\n')
+// Injected when a `channel_send` ack tripped continuation-willingness, the model
+// did fresh work after it, then ended on an EMPTY `stop` leaf — the answer was
+// computed but never sent (the Kimi/Fireworks empty-completion flake). Distinct
+// from WILLINGNESS_NUDGE: that path is a `channel_reply` that ended the turn and
+// needs `continue: true`; this path is a `channel_send` (which never ends the
+// turn) whose follow-up degenerated, so the model just needs to emit the reply it
+// already worked out. Shares MAX_WILLINGNESS_NUDGES so a turn can't double-nudge.
+export const SEND_WILLINGNESS_NUDGE = [
+  '---',
+  '**[SYSTEM MESSAGE — not from a human]**',
+  '',
+  'You said you would keep working this turn and did the work, but the turn ended',
+  'without sending the result — nothing reached the channel after your last',
+  'message. This is an automated signal from the channel router, not a message',
+  'from anyone in the chat. **Do not acknowledge or reply to this notice itself.**',
+  '',
+  'Send the answer you just worked out now via your channel send tool. If you',
+  'genuinely have nothing to report, reply with `NO_REPLY`.',
+  '',
+  '---',
+].join('\n')
 // Rolling window for outbound send-rate telemetry. 5s matches Discord's
 // rate-limit shape (5 msg / 5 s / channel) and comfortably covers Slack's
 // 1 msg/s sustained. The window is observational; exceeding the burst
@@ -3387,6 +3408,43 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
     // landed — suppress it, as before.
     if (live.successfulChannelSends > successfulSendsBeforePrompt) {
       maybeNudgeContinuationWillingness(live)
+
+      // A `channel_send` ack that promised to keep working, fresh post-ack work,
+      // then an EMPTY `stop` leaf: the model computed the answer in its reasoning
+      // / tool results but never sent it (the Kimi/Fireworks empty-completion
+      // flake). `maybeNudgeContinuationWillingness` above can't catch this — it
+      // reads `lastTerminalReplyAbort`, which only a `channel_reply` sets;
+      // `channel_send` keeps the turn alive and stamps nothing. And the
+      // stranded-toolUse retry below requires `source !== 'leaf'`, but an empty
+      // `stop` leaf recovers as `source: 'leaf'`, so this shape would otherwise
+      // fall straight through to the `endsWithNoReplySignal('')` → `no_reply`
+      // classification. Discriminator (all on existing state, zero false positives
+      // measured across the session corpus): a send landed AND the just-sent text
+      // trips the precision-tuned willingness detector AND the turn-end leaf is a
+      // FRESH empty `stop` (different entry than the ack's leaf — so the model did
+      // post-ack work, not an ack-then-await-user stop). Bounded by
+      // MAX_WILLINGNESS_NUDGES (shared with the reply path); on exhaustion post the
+      // fallback rather than going silent, mirroring the stranded-toolUse path.
+      // Gated on an empty `promptQueue` (like maybeNudgeContinuationWillingness): a
+      // real inbound that coalesced into the just-finished prompt will be answered
+      // by the next drain pass, and drain() splices pending reminders into that
+      // batch — so injecting a stale recovery nudge would prepend it to a live user
+      // message. Skip the nudge AND the fallback in that case and let the trailing
+      // recovery below run; the queued inbound supersedes this turn's silence.
+      if (live.promptQueue.length === 0 && live.currentTurnAuthorId !== null && isEmptyStopAfterWillingnessAck(live)) {
+        if (live.willingnessNudges < MAX_WILLINGNESS_NUDGES) {
+          live.willingnessNudges++
+          logger.warn(
+            `[channels] ${live.keyId} send_willingness_nudge attempt=${live.willingnessNudges}/${MAX_WILLINGNESS_NUDGES} ` +
+              `cause=empty_stop_after_send_ack`,
+          )
+          live.pendingSystemReminders.push(SEND_WILLINGNESS_NUDGE)
+        } else {
+          await postEmptyTurnFallback('empty_stop_after_send_ack_nudges_exhausted')
+        }
+        return
+      }
+
       const trailing = recoverableAssistantText(live.session)
       if (trailing === null || trailing.source !== 'leaf') {
         // A `continue: true` status reply landed, then the turn stranded on an
@@ -5021,6 +5079,24 @@ function leafIsStrandedToolUse(session: AgentSession): boolean {
   return false
 }
 
+// True when the turn-end leaf is a FRESH empty `stop` (no text, no tool call,
+// distinct from the leaf in place at the last successful send) AND the most
+// recent send to this target was a continuation-willingness ack. This is the
+// `channel_send` analogue of the `channel_reply` willingness path: the model
+// acked "I'll check…", did post-ack work, then the follow-up came back as a
+// clean empty completion that would otherwise be read as a deliberate `NO_REPLY`.
+// The fresh-leaf check (`!== lastSendLeafId`) is what separates this degeneration
+// from a legitimate ack-then-stop where the model meant to wait for the user.
+function isEmptyStopAfterWillingnessAck(live: LiveSession): boolean {
+  const leaf = live.session.sessionManager.getLeafEntry()
+  if (!leaf || leaf.type !== 'message' || leaf.message.role !== 'assistant') return false
+  if (leaf.message.stopReason !== 'stop') return false
+  if (hasToolCall(leaf.message) || visibleAssistantText(leaf.message).trim() !== '') return false
+  if (leaf.id === live.lastSendLeafId) return false
+  const ackText = live.lastSentText.get(consecutiveSendKey(live.key.chat, live.key.thread))
+  return ackText !== undefined && detectContinuationWillingness(ackText)
+}
+
 function visibleAssistantText(message: AssistantMessage): string {
   return message.content
     .filter((block) => block.type === 'text')