openclaw-scheduler 0.2.5 → 0.2.7

package/dispatch/README.md

@@ -291,8 +291,8 @@ No manual token configuration needed on a standard OpenClaw install.
 
 When `--deliver-to` is set, dispatch registers a **scheduler watcher job**
 after dispatching the session. The watcher polls the session result every
-minute until the agent produces a reply, then delivers via the scheduler's
-`handleDelivery` pipeline.
+minute until the agent sends the structured `done` completion signal, then
+delivers via the scheduler's `handleDelivery` pipeline.
 
 ```
 dispatch enqueue --deliver-to <telegram-user-id>
@@ -316,6 +316,20 @@ dispatch enqueue --deliver-to <telegram-user-id>
 Exit 1 with no output = retry on next cron tick (no spam — `announce-always`
 only delivers when `output.trim()` is truthy).
 
+Quiet sessions are treated conservatively. The watcher does not mark a running
+job failed just because `sessions.json` or the JSONL transcript has been quiet
+for 60 seconds. For high/xhigh reasoning work, the first idle result probe waits
+at least 10 minutes, idle auto-resolution waits at least 20 minutes, and the hard
+failure ceiling is longer than the requested task timeout. Missing or ambiguous
+gateway/session liveness fails open to "still monitoring" until the hard timeout
+window or a clear terminal error.
+
+While a label is still `running`, a plain assistant reply is diagnostic only.
+Successful final delivery requires the agent-side `done` signal and its
+structured completion payload. If an older watcher records an error and the
+worker later sends a valid `done`, the later completion is authoritative and the
+stale error is cleared from the label.
+
 ### Progress check-ins from subagent sessions
 
 Subagent sessions run without PATH access to the `openclaw` CLI, so

package/dispatch/completion.mjs

@@ -34,6 +34,13 @@ const TEST_FRAGMENT_RE = /\b(?:test|tests|spec|coverage|lint|typecheck|tsc|eslin
 const TEST_APPLICABILITY_RE = /\b(?:test|tests|pytest|jest|vitest|mocha|cypress|playwright|npm\s+test|pnpm\s+test|yarn\s+test|cargo\s+test|go\s+test|rspec)\b/i;
 const TEST_NEGATION_RE = /\b(?:do\s+not|don't|dont|never|skip|without|no)\s+(?:run\s+)?(?:the\s+)?tests?\b/i;
 const PUSH_FORBIDDEN_RE = /\b(?:do\s+not|don't|dont|never|must\s+not|should\s+not)\s+(?:git\s+push|push)\b|\bno\s+push\b|\bwithout\s+pushing\b/i;
+const EXPLICIT_TECHNICAL_MARKER_RE = /\b(?:Technically|Technical details)\s*:\s*/i;
+const HUMAN_SUMMARY_SECTION_RE = /(?:^|\n)\s*(?:Human-readable summary|Human summary)\s*:\s*/i;
+const TECHNICAL_DETAILS_SECTION_RE = /(?:^|\n)\s*(?:Technical details?|Details(?:_technical)?)\s*:\s*/i;
+const HUMAN_SUMMARY_LABEL_RE = /^(?:human-readable summary|human summary)\s*:\s*/i;
+const TECHNICAL_DETAILS_LABEL_RE = /^(?:technical details?|details(?:_technical)?)\s*:\s*/i;
+const FINAL_REPORT_HEADING_RE = /^(?:#{1,6}\s*)?(?:root cause|files? changed|changes|validation|tests?(?: run| passed)?|sacrificial(?: delivery)?(?: result)?|deployment(?:\/live-runtime)?(?: step)?|live-runtime(?: step)?|result|results|summary|highlights?|notes?|follow[- ]ups?|next steps?|blockers?|implementation|what changed|verification)\s*:?$/i;
+const FINAL_REPORT_CUE_RE = /\b(?:root cause|files? changed|tests? run|validation|sacrificial(?: delivery)?(?: result)?|deployment(?:\/live-runtime)?(?: step)?|live-runtime(?: step)?|final report|human-readable report|files changed|tests passed)\b/i;
 
 export function normalizeCompletionText(value) {
   if (typeof value !== 'string') return null;
@@ -71,6 +78,56 @@ function cleanMarkdown(text) {
     .replace(/^>\s?/gm, '');
 }
 
+function normalizeReportLineEndings(text) {
+  const normalized = normalizeCompletionText(text);
+  if (!normalized) return null;
+  return stripAnsi(normalized)
+    .replace(/\r\n?/g, '\n')
+    .split('\n')
+    .map(line => line.replace(/[ \t]+$/g, ''))
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function isLikelyHumanFinalReport(text) {
+  const normalized = normalizeReportLineEndings(text);
+  if (!normalized) return false;
+  if (isGenericOrTrivial(normalized)) return false;
+  if (isInternalTransportNoiseText(normalized)) return false;
+  if (looksLikeRawPayloadText(normalized)) return false;
+  if (looksLikeGunbrokerReport(normalized)) return false;
+
+  const rawLines = normalized
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .filter(line => !/^```/.test(line));
+  if (rawLines.length < 3) return false;
+
+  const cleanedLines = rawLines.map(line => cleanMarkdown(line).replace(/\s+/g, ' ').trim());
+  const headingCount = cleanedLines.filter(line => FINAL_REPORT_HEADING_RE.test(line)).length;
+  const itemCount = rawLines.filter(isItemLine).length;
+  const hasCue = FINAL_REPORT_CUE_RE.test(normalized);
+  const hasSectionLabel = /^#{1,6}\s+\S|^[A-Za-z][A-Za-z0-9 /_-]{2,60}:$/m.test(normalized);
+
+  // This is the key path for real completion reports from agents: multiple
+  // human-readable sections plus bullets. Those reports are already the final
+  // answer and must not be collapsed into "Files changed: Validation: ...".
+  if (hasCue && headingCount >= 2 && (itemCount >= 1 || rawLines.length >= 5)) return true;
+
+  // Allow slightly shorter reports with an explicit root cause / validation shape.
+  if (hasCue && headingCount >= 1 && itemCount >= 2 && hasSectionLabel) return true;
+
+  return false;
+}
+
+function getPassThroughHumanFinalReport(text) {
+  const normalized = normalizeReportLineEndings(text);
+  if (!normalized) return null;
+  return isLikelyHumanFinalReport(normalized) ? normalized : null;
+}
+
 function isGenericOrTrivial(text) {
   const normalized = normalizeCompletionText(text)?.toLowerCase().replace(/\s+/g, ' ').trim();
   if (!normalized) return true;
@@ -205,6 +262,80 @@ function upperFirst(text) {
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
 
+function extractExplicitTechnicalTail(text) {
+  const normalized = normalizeCompletionText(text);
+  if (!normalized) return null;
+
+  const match = EXPLICIT_TECHNICAL_MARKER_RE.exec(normalized);
+  if (!match || typeof match.index !== 'number' || match.index <= 0) return null;
+
+  const lead = normalizeCompletionText(normalized.slice(0, match.index));
+  const technicalTail = normalizeCompletionText(normalized.slice(match.index + match[0].length));
+  if (!lead || !technicalTail) return null;
+
+  return { lead, technicalTail };
+}
+
+function extractStructuredSummarySections(text) {
+  const normalized = normalizeCompletionText(text);
+  if (!normalized) return null;
+
+  const cleaned = cleanMarkdown(normalized).replace(/\r\n?/g, '\n').trim();
+  if (!cleaned) return null;
+
+  const humanMatch = HUMAN_SUMMARY_SECTION_RE.exec(cleaned);
+  const technicalMatch = TECHNICAL_DETAILS_SECTION_RE.exec(cleaned);
+  if (!humanMatch && !technicalMatch) return null;
+
+  let summary = null;
+  let technical = null;
+
+  if (humanMatch) {
+    const summaryStart = humanMatch.index + humanMatch[0].length;
+    const summaryEnd = technicalMatch && technicalMatch.index > humanMatch.index
+      ? technicalMatch.index
+      : cleaned.length;
+    summary = normalizeCompletionText(cleaned.slice(summaryStart, summaryEnd));
+  }
+
+  if (technicalMatch) {
+    const technicalStart = technicalMatch.index + technicalMatch[0].length;
+    technical = normalizeCompletionText(cleaned.slice(technicalStart));
+  }
+
+  if (!summary && !technical) return null;
+  return { summary, technical };
+}
+
+function stripHumanSummaryLabel(text) {
+  const normalized = normalizeCompletionText(text);
+  if (!normalized) return null;
+
+  const sections = extractStructuredSummarySections(normalized);
+  if (sections?.summary) return normalizeCompletionText(sections.summary);
+  return normalizeCompletionText(normalized.replace(HUMAN_SUMMARY_LABEL_RE, ''));
+}
+
+function normalizeTechnicalDetailLine(text) {
+  const normalized = normalizeCompletionText(text);
+  if (!normalized) return null;
+
+  const sections = extractStructuredSummarySections(normalized);
+  const source = normalizeCompletionText(sections?.technical || normalized);
+  if (!source) return null;
+
+  const lines = prepareLines(source)
+    .map(line => line
+      .replace(HUMAN_SUMMARY_LABEL_RE, '')
+      .replace(TECHNICAL_DETAILS_LABEL_RE, '')
+      .replace(/^[-*•]\s+/, '')
+      .trim())
+    .filter(Boolean);
+
+  const compact = normalizeCompletionText(lines.join(' '));
+  return compact || null;
+}
+
 function looksLikeRawPayloadText(text) {
   const normalized = normalizeCompletionText(text);
   if (!normalized) return false;
@@ -409,6 +540,107 @@ function cleanTechnicalFragment(text) {
   return cleaned || null;
 }
 
+function cleanLeadForHumanSummary(text) {
+  const normalized = normalizeCompletionText(text);
+  if (!normalized) return null;
+
+  const cleaned = replaceTechnicalPhrases(
+    cleanMarkdown(normalized)
+      .replace(/\bsaved\s+[a-z0-9_]+(?:\/[a-z0-9_]+)+\b/gi, 'your saved progress')
+      .replace(/\b([a-z][A-Za-z0-9_]*[A-Z][A-Za-z0-9_]*)\b/g, (_, token) => humanizeCamelToken(token))
+      .replace(/\b([a-z0-9]+_[a-z0-9_]+)\b/g, token => token.replace(/_/g, ' ')),
+  )
+    .replace(/\brepeating the completed one\b/gi, 'repeating the one you already finished')
+    .replace(/\s+,/g, ',')
+    .replace(/\s+\./g, '.')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  return cleaned || null;
+}
+
+function formatMixedTechnicalSubject(subject) {
+  let cleaned = normalizeCompletionText(subject);
+  if (!cleaned) return 'the missing data';
+
+  cleaned = replaceTechnicalPhrases(
+    cleanMarkdown(cleaned)
+      .replace(/\bhealth auto export\b/gi, 'source export')
+      .replace(/\bworkouts?\.json\b/gi, 'the export')
+      .replace(/\b([a-z][A-Za-z0-9_]*[A-Z][A-Za-z0-9_]*)\b/g, (_, token) => humanizeCamelToken(token))
+      .replace(/\b([a-z0-9]+_[a-z0-9_]+)\b/g, token => token.replace(/_/g, ' ')),
+  )
+    .replace(/^the\s+(?!missing\b)/i, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  if (!cleaned) return 'the missing data';
+  if (/^the\s+missing\b/i.test(cleaned)) return cleaned;
+  if (/^missing\b/i.test(cleaned)) return `the ${cleaned}`;
+  if (/^(?:the|your|this|that)\b/i.test(cleaned)) return cleaned;
+  return `the ${cleaned}`;
+}
+
+function buildSourceSideHumanSentence(technicalTail) {
+  const normalized = cleanMarkdown(normalizeCompletionText(technicalTail) || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!normalized) return null;
+
+  const hasSourceSide = /\bsource[- ]side\b/i.test(normalized);
+  const hasEmptySource = /\b(?:contains zero|count 0|empty|zero [a-z ]+ objects?|no [a-z ]+ to import)\b/i.test(normalized);
+  if (!hasSourceSide && !hasEmptySource) return null;
+
+  const subjectMatch = normalized.match(/\b(?:confirmed|found|verified|checked)\s+(the\s+missing\s+.+?)\s+is\s+source[- ]side\b/i)
+    || normalized.match(/\b(the\s+missing\s+.+?)\s+is\s+source[- ]side\b/i)
+    || normalized.match(/\b(?:confirmed|found|verified|checked)\s+(.+?)\s+is\s+source[- ]side\b/i)
+    || normalized.match(/\b(.+?)\s+is\s+source[- ]side\b/i);
+  const subject = formatMixedTechnicalSubject(subjectMatch?.[1] || 'missing data');
+
+  if (hasEmptySource) {
+    return `I also checked ${subject}, and the source export is empty right now, so there isn't anything new to import yet.`;
+  }
+
+  return `I also checked ${subject}, and this turned out to be a source-data issue rather than a new scheduler bug.`;
+}
+
+function buildMixedLeadExpectation(text) {
+  const normalized = cleanMarkdown(normalizeCompletionText(text) || '').toLowerCase();
+  if (!normalized) return null;
+  if (/\b(?:next|should|will)\b/.test(normalized)) return null;
+
+  if (/\b(?:planner|plan|scheduled session|session|progression|workout)\b/.test(normalized)) {
+    return 'The next plan should reflect that automatically.';
+  }
+  if (/\b(?:completion|summary|delivery|message|report)\b/.test(normalized)) {
+    return 'The next finished job should show that automatically.';
+  }
+  if (/\b(?:import|sync)\b/.test(normalized)) {
+    return 'The next sync should reflect that automatically.';
+  }
+  return 'The next run should reflect that automatically.';
+}
+
+function buildHumanSummaryFromMixedTechnicalText(rawText) {
+  const split = extractExplicitTechnicalTail(rawText);
+  if (!split) return null;
+
+  const cleanedLead = cleanLeadForHumanSummary(split.lead);
+  const leadSummary = cleanedLead
+    ? summarizeCompletionText(cleanedLead, { skipEmbeddedObject: true }) || summarizeProse(cleanedLead) || asSentence(cleanedLead)
+    : null;
+  if (!leadSummary) return null;
+
+  const sentences = [leadSummary];
+  const sourceSideSentence = buildSourceSideHumanSentence(split.technicalTail);
+  if (sourceSideSentence) sentences.push(sourceSideSentence);
+
+  const expectation = buildMixedLeadExpectation(sentences.join(' '));
+  if (expectation) sentences.push(expectation);
+
+  return truncateText(sentences.join(' '), MAX_DELIVERY_CHARS);
+}
+
 function isTestOrValidationFragment(fragment) {
   const cleaned = normalizeCompletionText(fragment);
   if (!cleaned) return false;
@@ -578,11 +810,21 @@ export function humanizeCompletionText(value) {
   const raw = normalizeCompletionText(value);
   if (!raw) return null;
 
-  const summarized = summarizeCompletionText(raw);
+  const passThroughReport = getPassThroughHumanFinalReport(raw);
+  if (passThroughReport) return passThroughReport;
+
+  const structuredSections = extractStructuredSummarySections(raw);
+  const summarySource = normalizeCompletionText(structuredSections?.summary || raw);
+  if (!summarySource) return null;
+
+  const mixedSummary = buildHumanSummaryFromMixedTechnicalText(summarySource);
+  if (mixedSummary) return mixedSummary;
+
+  const summarized = summarizeCompletionText(summarySource);
   if (!summarized) return null;
-  if (!looksTechnicalCompletionSummary(raw, summarized)) return summarized;
+  if (!looksTechnicalCompletionSummary(summarySource, summarized)) return stripHumanSummaryLabel(summarized) || summarized;
 
-  return buildHumanizedTechnicalSummary(raw, summarized) || summarized;
+  return buildHumanizedTechnicalSummary(summarySource, summarized) || summarized;
 }
 
 function summarizeChecklistTechnicalDetails(checklist, sha) {
@@ -615,29 +857,47 @@ function buildTechnicalDetailsText({ rawText, summaryText, completion } = {}) {
   const details = getCompletionTechnicalDetails(completion);
   const parts = [];
 
-  const rawTechnical = raw && looksTechnicalCompletionSummary(raw, summary) && raw !== summary;
+  const rawSections = extractStructuredSummarySections(raw);
+  const splitRaw = extractExplicitTechnicalTail(raw);
+  const rawTechnicalSource = normalizeTechnicalDetailLine(rawSections?.technical || splitRaw?.technicalTail || raw);
+  const rawHasExplicitTechnical = Boolean(rawSections?.technical || splitRaw?.technicalTail);
+
+  const rawTechnical = Boolean(
+    rawTechnicalSource
+      && ((rawHasExplicitTechnical && rawTechnicalSource !== summary)
+        || (looksTechnicalCompletionSummary(rawTechnicalSource, summary) && rawTechnicalSource !== summary)),
+  );
   if (rawTechnical) {
-    parts.push(truncateText(cleanMarkdown(raw).replace(/\s+/g, ' ').trim(), 260));
+    parts.push(truncateText(rawTechnicalSource, 260));
   }
 
   let completionDetailsAreTechnical = false;
   if (typeof details === 'string') {
-    const normalized = normalizeCompletionText(details);
-    completionDetailsAreTechnical = Boolean(normalized && looksTechnicalCompletionSummary(normalized, summary));
+    const detailSections = extractStructuredSummarySections(details);
+    const splitDetails = extractExplicitTechnicalTail(details);
+    const normalized = normalizeTechnicalDetailLine(detailSections?.technical || splitDetails?.technicalTail || details);
+    completionDetailsAreTechnical = Boolean(
+      normalized && (detailSections?.technical || splitDetails?.technicalTail || looksTechnicalCompletionSummary(normalized, summary)),
+    );
     if (normalized
       && !isInternalTransportNoiseText(normalized)
       && (completionDetailsAreTechnical || rawTechnical)
-      && (!rawTechnical || normalized !== raw)) {
+      && (!rawTechnical || normalized !== rawTechnicalSource)) {
       parts.push(truncateText(normalized, 220));
     }
   } else if (details && typeof details === 'object') {
     const rawSummary = normalizeCompletionText(details.raw_summary);
-    completionDetailsAreTechnical = Boolean(rawSummary && looksTechnicalCompletionSummary(rawSummary, summary));
-    if (rawSummary
-      && !isInternalTransportNoiseText(rawSummary)
+    const detailSummarySections = extractStructuredSummarySections(rawSummary);
+    const splitDetailSummary = extractExplicitTechnicalTail(rawSummary);
+    const technicalSummary = normalizeTechnicalDetailLine(detailSummarySections?.technical || splitDetailSummary?.technicalTail || rawSummary);
+    completionDetailsAreTechnical = Boolean(
+      technicalSummary && (detailSummarySections?.technical || splitDetailSummary?.technicalTail || looksTechnicalCompletionSummary(technicalSummary, summary)),
+    );
+    if (technicalSummary
+      && !isInternalTransportNoiseText(technicalSummary)
       && (completionDetailsAreTechnical || rawTechnical)
-      && (!rawTechnical || rawSummary !== raw)) {
-      parts.push(truncateText(cleanMarkdown(rawSummary).replace(/\s+/g, ' ').trim(), 220));
+      && (!rawTechnical || technicalSummary !== rawTechnicalSource)) {
+      parts.push(truncateText(technicalSummary, 220));
     }
   }
 
@@ -647,7 +907,7 @@ function buildTechnicalDetailsText({ rawText, summaryText, completion } = {}) {
   const unique = [];
   const seen = new Set();
   for (const part of parts) {
-    const normalized = normalizeCompletionText(part);
+    const normalized = normalizeTechnicalDetailLine(part) || normalizeCompletionText(part);
     if (!normalized) continue;
     const key = normalized.toLowerCase();
     if (seen.has(key)) continue;
@@ -659,22 +919,39 @@ function buildTechnicalDetailsText({ rawText, summaryText, completion } = {}) {
 }
 
 function composeDeliveryText(summaryText, technicalDetailsText = null) {
-  const summary = normalizeCompletionText(summaryText);
+  const summarySections = extractStructuredSummarySections(summaryText);
+  const summary = stripHumanSummaryLabel(summarySections?.summary || summaryText);
   if (!summary) return null;
-  const technicalLines = Array.isArray(technicalDetailsText)
-    ? technicalDetailsText.map(line => normalizeCompletionText(line)).filter(Boolean)
-    : [];
+
+  const technicalCandidates = [];
+  if (summarySections?.technical) technicalCandidates.push(summarySections.technical);
+  if (Array.isArray(technicalDetailsText)) technicalCandidates.push(...technicalDetailsText);
+  else if (technicalDetailsText != null) technicalCandidates.push(technicalDetailsText);
+
+  const technicalLines = [];
+  const seen = new Set();
+  for (const candidate of technicalCandidates) {
+    const normalized = normalizeTechnicalDetailLine(candidate);
+    if (!normalized) continue;
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    technicalLines.push(normalized);
+  }
+
   if (technicalLines.length > 0) {
     return `${summary}\n\nTechnical details:\n- ${technicalLines.join('\n- ')}`;
   }
-  const technical = normalizeCompletionText(technicalDetailsText);
-  return technical ? `${summary}\n\nTechnical details:\n- ${technical}` : summary;
+  return summary;
 }
 
 export function summarizeCompletionText(value, { skipEmbeddedObject = false } = {}) {
   const raw = normalizeCompletionText(value);
   if (!raw) return null;
 
+  const passThroughReport = getPassThroughHumanFinalReport(raw);
+  if (passThroughReport) return passThroughReport;
+
   if (!skipEmbeddedObject) {
     const parsed = extractEmbeddedCompletionObject(raw);
     if (parsed !== null) {