@adhdev/daemon-core 0.9.82-rc.44 → 0.9.82-rc.441

package/src/providers/approval-utils.ts

@@ -24,6 +24,23 @@ function normalizeApprovalLabel(value: string): string {
         .trim();
 }
 
+function isNegativeApprovalLabel(value: string): boolean {
+    const label = normalizeApprovalLabel(value);
+    return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label)
+        || /\bwithout\b/.test(label)
+        || /\bdo not\b/.test(label);
+}
+
+/**
+ * True when any of the given button labels reads as a decline/negative option
+ * (No / Deny / Cancel / Skip / …). Used as the second half of an approval-modal
+ * structural anchor: a real approval modal offers BOTH an affirmative and a
+ * decline, which distinguishes it from a generic numbered menu or prose list.
+ */
+export function hasNegativeApprovalOption(buttons: string[] | null | undefined): boolean {
+    return (buttons || []).some((button) => isNegativeApprovalLabel(String(button || '')));
+}
+
 export function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[] {
     const customHints = Array.isArray(provider?.approvalPositiveHints)
         ? provider.approvalPositiveHints
@@ -39,24 +56,32 @@ export function pickApprovalButton(
 ): { index: number; label: string } {
     const labels = (buttons || []).map((button) => String(button || '').trim()).filter(Boolean);
     if (labels.length === 0) {
-        return { index: 0, label: 'Approve' };
+        return { index: -1, label: '' };
     }
 
     const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
     const hints = getApprovalPositiveHints(provider);
 
     for (const hint of hints) {
-        const exactIndex = normalizedButtons.findIndex((label) => label === hint);
+        const exactIndex = normalizedButtons.findIndex((label, index) => label === hint && !isNegativeApprovalLabel(labels[index]));
         if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
 
-        const prefixIndex = normalizedButtons.findIndex((label) => label.startsWith(hint));
+        const prefixIndex = normalizedButtons.findIndex((label, index) => label.startsWith(hint) && !isNegativeApprovalLabel(labels[index]));
         if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
 
-        const includeIndex = normalizedButtons.findIndex((label) => label.includes(hint));
+        const includeIndex = normalizedButtons.findIndex((label, index) => label.includes(hint) && !isNegativeApprovalLabel(labels[index]));
         if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
     }
 
-    return { index: 0, label: labels[0] };
+    return { index: -1, label: '' };
+}
+
+export function pickAutoApprovalButton(
+    buttons: string[] | null | undefined,
+): { index: number; label: string } {
+    const labels = (buttons || []).map((button) => String(button || '').trim());
+    const index = labels.findIndex(Boolean);
+    return index >= 0 ? { index, label: labels[index] } : { index: -1, label: '' };
 }
 
 export function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: string): string {
@@ -65,3 +90,30 @@ export function formatAutoApprovalMessage(modalMessage?: string, buttonLabel?: s
     if (cleanMessage) lines.push(cleanMessage);
     return lines.join('\n');
 }
+
+/**
+ * Returns true when the given text (e.g. last assistant message content, or
+ * the tail of the PTY screen) looks like an active approval/input prompt
+ * rather than a completed assistant response. Used to prevent false
+ * idle/completion events when Claude Code surfaces a "Do you want to proceed?"
+ * style prompt that the PTY parser captures as an assistant turn while the
+ * session is still awaiting user input.
+ */
+export function looksLikeActiveApprovalPromptText(content: string): boolean {
+    const text = content.trim();
+    if (!text || text.length > 2000) return false;
+    const hasApprovalQuestion = /do you want to (?:proceed|allow|run|make this edit|create)/i.test(text)
+        || /this command requires approval/i.test(text)
+        || /quick safety check/i.test(text)
+        || /is this a project you trust/i.test(text);
+    const hasNumberedChoices = /^\s*[❯›>]?\s*1[.)]\s+(?:yes|allow|proceed|run)/im.test(text)
+        || /^\s*1[.)]\s+yes\b/im.test(text);
+    if (hasApprovalQuestion && hasNumberedChoices) return true;
+    const lastLines = text.split(/\r?\n/).slice(-12).join('\n');
+    const hasDontAskAgain = /yes.*don'?t ask again/i.test(lastLines)
+        || /yes.*always allow/i.test(lastLines);
+    const hasNoOption = /^\s*[❯›>]?\s*\d+[.)]\s+no\b/im.test(lastLines);
+    if (hasDontAskAgain && hasNoOption) return true;
+    if (/what do you want to do\?/i.test(text) && /^\s*\d+[.)]\s+\S/m.test(text)) return true;
+    return false;
+}

package/src/providers/chat-message-normalization.ts

@@ -1,7 +1,7 @@
 import type { ChatMessage } from '../types.js';
 import { flattenContent } from './contracts.js';
 
-export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4_000;
+export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16_000;
 
 export function extractFinalSummaryFromMessages(
   messages: ChatMessage[] | null | undefined,
@@ -20,20 +20,108 @@ export function extractFinalSummaryFromMessages(
     }
   }
 
-  // Fallback: last user-facing message of any role
+  // Completion summaries must describe the assistant/model result. If no
+  // user-facing assistant/model message exists yet (for example, only the
+  // dispatched user prompt is visible), return empty instead of echoing the
+  // prompt as a misleading finalSummary.
+  return '';
+}
+
+function readChatMessageTimestampMs(message: ChatMessage | null | undefined): number | undefined {
+  if (!message) return undefined;
+  const record = message as ChatMessage & Record<string, unknown>;
+  for (const value of [record.timestamp, record.createdAt, record.created_at, record.updatedAt, record.time, record.receivedAt]) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      // Heuristic seconds-vs-ms detection mirrors the mesh transcript reader.
+      return value > 10_000_000_000 ? value : value * 1000;
+    }
+    if (typeof value === 'string' && value.trim()) {
+      const ms = new Date(value.trim()).getTime();
+      if (Number.isFinite(ms)) return ms;
+    }
+  }
+  return undefined;
+}
+
+function readChatMessageTimestampIso(message: ChatMessage | null | undefined): string | undefined {
+  const ms = readChatMessageTimestampMs(message);
+  return typeof ms === 'number' ? new Date(ms).toISOString() : undefined;
+}
+
+/**
+ * Turn-scoped variant of extractFinalSummaryFromMessages. Selects the last
+ * user-facing assistant/model bubble whose own timestamp is at/after the
+ * producing turn's start (`minTimestampMs`). This is the NOTIF Defect-B fix:
+ * a completion event's finalSummary must describe the turn THAT completed, not
+ * the prior task's last bubble. For native-source providers (claude-cli) the
+ * external transcript holds the ENTIRE session history filtered only by session
+ * start, so a completion debounce that fires before the producing turn's final
+ * assistant bubble has landed would otherwise echo the previous task's tail.
+ * A message whose timestamp predates the turn start is skipped; if no in-turn
+ * assistant bubble exists yet, returns '' (weak/empty) — never the stale tail.
+ *
+ * Mirrors the reconcile path's transcriptAfterDispatch guard (mesh-events-stale):
+ * a bubble only counts if its timestamp proves it was produced after the turn began.
+ * When `minTimestampMs` is undefined the behaviour is identical to the unscoped
+ * extractor (no turn boundary known → no filtering).
+ */
+export function extractFinalSummaryFromMessagesAfter(
+  messages: ChatMessage[] | null | undefined,
+  minTimestampMs: number | undefined,
+  maxChars: number = DEFAULT_FINAL_SUMMARY_MAX_CHARS,
+): string {
+  if (!Array.isArray(messages) || messages.length === 0) return '';
+  const hasBoundary = typeof minTimestampMs === 'number' && Number.isFinite(minTimestampMs);
+
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (!msg) continue;
+    if (hasBoundary) {
+      // A bubble carrying a timestamp BEFORE the producing turn's start belongs to
+      // a prior task — skip it. A bubble with no parseable timestamp cannot be
+      // proven stale, so it is kept (the unscoped fallback) rather than dropped.
+      const ts = readChatMessageTimestampMs(msg);
+      if (typeof ts === 'number' && ts < (minTimestampMs as number)) continue;
+    }
     const classification = classifyChatMessageVisibility(msg);
-    if (classification.isUserFacing) {
+    if (classification.isUserFacing && (msg.role === 'assistant' || msg.role === 'model')) {
       const text = flattenContent(msg.content).trim();
       if (text) return text.slice(0, maxChars);
     }
   }
-
   return '';
 }
 
+/**
+ * Like extractFinalSummaryFromMessages but also returns the ISO timestamp of the
+ * selected final assistant/model message. Completion reconciliation needs the
+ * timestamp to prove the transcript was produced AFTER the dispatch — without it
+ * reconcileDirectDispatchCompletionFromTranscript rejects non-JSON summaries as
+ * "transcript_not_proven_after_dispatch". The summary selection is identical so the
+ * timestamp always belongs to the message whose text became the summary.
+ */
+export function extractFinalAssistantSummaryEvidence(
+  messages: ChatMessage[] | null | undefined,
+  maxChars: number = DEFAULT_FINAL_SUMMARY_MAX_CHARS,
+): { finalSummary: string; transcriptMessageAt?: string } {
+  if (!Array.isArray(messages) || messages.length === 0) return { finalSummary: '' };
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg) continue;
+    const classification = classifyChatMessageVisibility(msg);
+    if (classification.isUserFacing && (msg.role === 'assistant' || msg.role === 'model')) {
+      const text = flattenContent(msg.content).trim();
+      if (text) {
+        return {
+          finalSummary: text.slice(0, maxChars),
+          transcriptMessageAt: readChatMessageTimestampIso(msg),
+        };
+      }
+    }
+  }
+  return { finalSummary: '' };
+}
+
 export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'terminal', 'system'] as const;
 
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];