openclaw-scheduler 0.2.4 → 0.2.5

package/dispatch/message-input.mjs

@@ -0,0 +1,67 @@
+import { readFileSync } from 'fs';
+import { isatty } from 'node:tty';
+
+function normalizeFlagValue(value, flagName) {
+  if (value === undefined || value === null) return null;
+  if (value === true) throw new Error(`${flagName} requires a value`);
+  return String(value);
+}
+
+export async function resolveMessageInput({
+  message = null,
+  messageFile = null,
+  messageEnv = null,
+  messageStdin = false,
+  stdinIsTTY = isatty(0),
+  env = process.env,
+  readFile = (path) => readFileSync(path, 'utf8'),
+  readStdin = () => readFileSync(0, 'utf8'),
+} = {}) {
+  const directMessage = normalizeFlagValue(message, '--message');
+  const filePath = normalizeFlagValue(messageFile, '--message-file');
+  const envVar = normalizeFlagValue(messageEnv, '--message-env');
+  const wantsStdin = messageStdin === true || messageStdin === 'true';
+
+  const explicitSources = [];
+  if (directMessage !== null) explicitSources.push('--message');
+  if (filePath !== null) explicitSources.push('--message-file');
+  if (envVar !== null) explicitSources.push('--message-env');
+  if (wantsStdin) explicitSources.push('--message-stdin');
+
+  if (explicitSources.length > 1) {
+    throw new Error(`choose only one of ${explicitSources.join(', ')} for the prompt source`);
+  }
+
+  if (directMessage !== null) return directMessage;
+
+  if (filePath !== null) {
+    if (filePath === '-') {
+      if (stdinIsTTY === true) throw new Error('--message-file - requires piped stdin');
+      return readStdin();
+    }
+    try {
+      return readFile(filePath);
+    } catch (err) {
+      throw new Error(`--message-file: could not read file: ${err.message}`, { cause: err });
+    }
+  }
+
+  if (envVar !== null) {
+    if (!Object.prototype.hasOwnProperty.call(env, envVar)) {
+      throw new Error(`--message-env: environment variable ${envVar} is not set`);
+    }
+    return String(env[envVar] ?? '');
+  }
+
+  if (wantsStdin) {
+    if (stdinIsTTY === true) throw new Error('--message-stdin requires piped stdin');
+    return readStdin();
+  }
+
+  if (stdinIsTTY !== true) {
+    const pipedText = readStdin();
+    return pipedText.length > 0 ? pipedText : null;
+  }
+
+  return null;
+}

package/dispatch/watcher.mjs

@@ -31,7 +31,11 @@ import { readFileSync, writeFileSync, renameSync, statSync } from 'fs';
 import { dirname, join } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
-import { resolveCompletionDelivery } from './completion.mjs';
+import {
+  extractTerminalAssistantReplyFromEntries,
+  hasCompletionSignal,
+  resolveCompletionDelivery,
+} from './completion.mjs';
 import { sendMessage } from '../messages.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -586,6 +590,28 @@ function readJsonlLastLines(sessionId, agentDir = 'main', n = 3) {
   }
 }
 
+function readJsonlTailEntries(sessionId, agentDir = 'main', n = 200) {
+  return readJsonlLastLines(sessionId, agentDir, n);
+}
+
+function getSessionTerminalReply(sessionId, agentDir = 'main') {
+  const entries = readJsonlTailEntries(sessionId, agentDir, 200);
+  return extractTerminalAssistantReplyFromEntries(entries);
+}
+
+function formatDiagnosticSnippet(reply) {
+  if (!reply || typeof reply !== 'string') return '';
+  const normalized = reply.trim();
+  if (!normalized) return '';
+
+  const maxLen = 1200;
+  const clipped = normalized.length > maxLen
+    ? normalized.slice(0, maxLen) + '\n\n..[truncated]'
+    : normalized;
+
+  return `\n\nLast assistant report observed:\n${clipped}`;
+}
+
 /**
  * Check if a session is currently mid-turn by inspecting its JSONL tail.
  * Returns a reason string if mid-turn is detected, null if safe to proceed.
@@ -796,6 +822,21 @@ function deliverResult(label, lastReply, fallbackSummary, completionPayload = nu
   process.exit(0);
 }
 
+function emitInterruptedOutcome(label, summary, result = null) {
+  process.stderr.write(`[watcher] [${label}] session auto-resolved as interrupted -- work may be incomplete\n`);
+  markLabelError(label, summary || 'interrupted: session went idle without calling done');
+  process.stdout.write(
+    `⚠️ dispatch [${label}] session went idle before completing -- work may be incomplete` +
+    `${formatDiagnosticSnippet(result?.diagnosticReply || result?.lastReply || null)}\n`
+  );
+  process.exit(1);
+}
+
+function emitTimeoutOutcome(label, message, result = null) {
+  process.stdout.write(`${message}${formatDiagnosticSnippet(result?.diagnosticReply || result?.lastReply || null)}\n`);
+  process.exit(1);
+}
+
 // -- Watcher heartbeat interval ref --------------------------------------
 // Populated after label is validated (in main body). Cleared on exit.
 // The interval writes lastPing to labels.json so the watchdog guard in
@@ -870,17 +911,47 @@ let lastKnownReply = null;
 let lastKnownCompletion = null;
 
 // -- SIGTERM handler (scheduler kills watcher with SIGTERM before SIGKILL) --
-// Ensures labels.json is updated and a delivery attempt is made even when killed.
+// Hand off to a fresh watcher instead of converting the kill into a fake success.
 process.on('SIGTERM', () => {
-  process.stderr.write(`[watcher] SIGTERM received for ${label} -- marking as interrupted\n`);
-  // Try to fetch the latest result before dying
+  process.stderr.write(`[watcher] SIGTERM received for ${label} -- attempting watcher handoff\n`);
+
+  let latestStatus = null;
+  try {
+    latestStatus = dispatch('status', ['--label', label]);
+  } catch {}
+
   try {
     const result = dispatch('result', ['--label', label]);
     if (result?.lastReply) lastKnownReply = result.lastReply;
     if (result?.completion) lastKnownCompletion = result.completion;
   } catch {}
-  // deliverResult calls process.exit(0) internally
-  deliverResult(label, lastKnownReply, 'interrupted by watcher timeout', lastKnownCompletion);
+
+  if (latestStatus?.status === 'done') {
+    deliverResult(label, lastKnownReply, latestStatus.summary || null, lastKnownCompletion || latestStatus?.completion || null);
+  }
+
+  if (latestStatus?.status === 'interrupted') {
+    markLabelError(label, latestStatus.summary || 'interrupted: session went idle without calling done');
+    process.exit(1);
+  }
+
+  if (latestStatus?.status && latestStatus.status !== 'running') {
+    const summary = latestStatus.error || latestStatus.summary || `terminal failure (${latestStatus.status})`;
+    markLabelError(label, summary);
+    process.stdout.write(`🌶️ *dispatch* [${label}] failed\nSummary: ${summary}\n`);
+    process.exit(1);
+  }
+
+  const handoff = dispatch('watcher-handoff', ['--label', label, '--reason', 'sigterm']);
+  if (handoff?.ok && (handoff.scheduled || handoff.reason === 'label already terminal' || handoff.reason === 'delivery disabled for this label')) {
+    process.stderr.write(`[watcher] SIGTERM handoff ${handoff.scheduled ? 'scheduled' : 'skipped'} for ${label}\n`);
+    process.exit(0);
+  }
+
+  const failureSummary = 'interrupted by watcher timeout (handoff failed)';
+  markLabelError(label, failureSummary);
+  process.stdout.write(`⚠️ dispatch [${label}] watcher interrupted and handoff failed\nSummary: ${failureSummary}\n`);
+  process.exit(1);
 });
 
 // -- Rolling deadline vars ------------------------------------
@@ -1024,11 +1095,21 @@ while (Date.now() < deadline) {
 
   // -- Path 1: status auto-resolved to done ------------------
   if (status.status !== 'running') {
+    const terminalResult = dispatch('result', ['--label', label]);
+    const terminalCompletion = terminalResult?.completion || status?.completion || null;
+    const hasTerminalCompletionEvidence = Boolean(
+      terminalResult?.lastReply
+      || terminalResult?.completion?.deliveryText
+      || terminalResult?.completion?.summary
+      || status?.completion?.deliveryText
+      || status?.completion?.summary
+    );
+
     // -- Spawn failure detection -----------------------------------------
     // If the session was auto-resolved to 'done' (or 'spawn-warning') but was
-    // never seen in the gateway, it never ran -- this is a spawn failure.
-    // Causes: auth timeout, quota exhaustion, gateway error at spawn time.
-    if (!sessionEverFound && (status.status === 'done' || status.status === 'spawn-warning' || status.status === 'error')) {
+    // never seen in the gateway, it never ran -- unless a terminal completion
+    // payload/reply proves the work already finished before this watcher saw it.
+    if (!sessionEverFound && (status.status === 'spawn-warning' || status.status === 'error' || (status.status === 'done' && !hasTerminalCompletionEvidence))) {
       const spawnErrMsg =
         `[dispatch] SPAWN FAILURE: session ${status.sessionKey || '(unknown)'} never appeared ` +
         `in gateway -- spawn likely failed (auth timeout, quota, or gateway error). Label: ${label}`;
@@ -1055,7 +1136,7 @@ while (Date.now() < deadline) {
     // If the session DID produce a lastReply before being killed, deliver it normally.
     if (sessionEverFound && isGatewayRestartKill(status.summary)) {
       const gwCheckResult = dispatch('result', ['--label', label]);
-      if (!gwCheckResult?.lastReply && !gwCheckResult?.completion?.deliveryText) {
+      if (!gwCheckResult?.lastReply && !hasCompletionSignal(gwCheckResult?.completion)) {
         // No result captured -- session was killed before completing
         const retryCount = getGwRestartRetryCount(label);
         if (retryCount >= MAX_GW_RESTART_RETRIES) {
@@ -1113,12 +1194,8 @@ while (Date.now() < deadline) {
     //
     // NOTE: Always resolve as 'interrupted', never 'done'. Only agent-side cmdDone may set status=done.
     if (status.status === 'interrupted') {
-      process.stderr.write(`[watcher] [${label}] session auto-resolved as interrupted -- work may be incomplete\n`);
-      process.stdout.write(
-        `⚠️ dispatch [${label}] session went idle before completing -- work may be incomplete\n`
-      );
-      markLabelError(label, status.summary || 'interrupted: session went idle without calling done');
-      process.exit(1);
+      const interruptedResult = dispatch('result', ['--label', label]);
+      emitInterruptedOutcome(label, status.summary, interruptedResult);
     }
 
     // Reset 529 retryCount on successful completion
@@ -1129,8 +1206,7 @@ while (Date.now() < deadline) {
         process.stderr.write(`[watcher] [${label}] completed after ${currentRetryCount} retry(ies), reset retryCount\n`);
       }
     }
-    const result = dispatch('result', ['--label', label]);
-    deliverResult(label, result?.lastReply, status.summary, result?.completion || status?.completion || null);
+    deliverResult(label, terminalResult?.lastReply, status.summary, terminalCompletion);
   }
 
   // -- Path 2a: stop_reason early delivery (clean end_turn) --
@@ -1141,10 +1217,11 @@ while (Date.now() < deadline) {
     const _e2a = getSessionStoreEntry(status.sessionKey);
     const _sid2a = _e2a?.sessionId || null;
     const _adir2a = (status.sessionKey.split(':')[1]) || 'main';
-    if (_sid2a && isSessionCleanlyFinished(_sid2a, _adir2a)) {
+    const terminalJsonlReply = _sid2a ? getSessionTerminalReply(_sid2a, _adir2a) : null;
+    if (_sid2a && terminalJsonlReply && isSessionCleanlyFinished(_sid2a, _adir2a)) {
       process.stderr.write(`[watcher] stop_reason=end_turn detected -- delivering early\n`);
       const result = dispatch('result', ['--label', label]);
-      deliverResult(label, result?.lastReply, 'completed (stop_reason=end_turn)', result?.completion || null);
+      deliverResult(label, result?.lastReply || terminalJsonlReply, 'completed (stop_reason=end_turn)', result?.completion || null);
       // deliverResult exits
     }
   }
@@ -1158,7 +1235,7 @@ while (Date.now() < deadline) {
   const ageMs = status.liveness?.ageMs;
   if (ageMs != null && ageMs >= IDLE_RESULT_CHECK_MS) {
     const result = dispatch('result', ['--label', label]);
-    if (result?.lastReply || result?.completion?.deliveryText) {
+    if (result?.lastReply || hasCompletionSignal(result?.completion)) {
       deliverResult(label, result?.lastReply || null, null, result?.completion || null);
     }
   }
@@ -1183,11 +1260,7 @@ if (finalStatus?.status === 'done') {
 // If status is interrupted (auto-resolved as incomplete), exit non-zero
 if (finalStatus?.status === 'interrupted') {
   process.stderr.write(`[watcher] [${label}] final status=interrupted -- session idle without completion\n`);
-  process.stdout.write(
-    `⚠️ dispatch [${label}] session went idle before completing -- work may be incomplete\n`
-  );
-  markLabelError(label, finalStatus?.summary || 'interrupted: session went idle without calling done');
-  process.exit(1);
+  emitInterruptedOutcome(label, finalStatus?.summary, finalResult);
 }
 
 // -- Token-based activity check before steering ----------------------------
@@ -1237,7 +1310,7 @@ if (sessionInternalId) {
 // If the session already completed (gateway pruned it -> null tokens), exit cleanly.
 if (statusAtDeadline?.status === 'done' || baselineTokens === null) {
   const r = dispatch('result', ['--label', label]);
-  if (r?.lastReply || r?.completion?.deliveryText) {
+  if (r?.lastReply || hasCompletionSignal(r?.completion)) {
     // deliverResult calls process.exit(0) internally
     deliverResult(label, r?.lastReply || null, statusAtDeadline?.summary || null, r?.completion || null);
   }
@@ -1255,8 +1328,7 @@ if (statusAtDeadline?.status === 'done' || baselineTokens === null) {
       // Session truly not found -- telemetry unavailable, exit
       process.stderr.write(`[watcher] token telemetry unavailable for ${label}; session not in store\n`);
       markLabelError(label, `timed out after ${timeoutS}s -- token telemetry unavailable`);
-      process.stdout.write(`⏱ dispatch [${label}] timed out after ${timeoutS}s -- token telemetry unavailable; no steer/kill attempted\n`);
-      process.exit(1);
+      emitTimeoutOutcome(label, `⏱ dispatch [${label}] timed out after ${timeoutS}s -- token telemetry unavailable; no steer/kill attempted`, r);
     }
     // Session IS in store but no tokens -- mid-tool-call, fall through to activity window
     // Use updatedAt as activity signal instead of tokens
@@ -1277,7 +1349,7 @@ while (Date.now() - flatSince < FLAT_WINDOW_MS) {
     deliverResult(label, r?.lastReply || null, st.summary, r?.completion || st?.completion || null);
   }
   const r2 = dispatch('result', ['--label', label]);
-  if (r2?.lastReply || r2?.completion?.deliveryText) {
+  if (r2?.lastReply || hasCompletionSignal(r2?.completion)) {
     // deliverResult calls process.exit(0) internally
     deliverResult(label, r2?.lastReply || null, null, r2?.completion || null);
   }
@@ -1290,8 +1362,8 @@ while (Date.now() - flatSince < FLAT_WINDOW_MS) {
     if (!entry) {
       process.stderr.write(`[watcher] token telemetry lost for ${label}; session gone from store\n`);
       markLabelError(label, `timed out after ${timeoutS}s -- token telemetry lost`);
-      process.stdout.write(`⏱ dispatch [${label}] timed out after ${timeoutS}s -- token telemetry lost; no steer/kill attempted\n`);
-      process.exit(1);
+      const tokenLostResult = dispatch('result', ['--label', label]);
+      emitTimeoutOutcome(label, `⏱ dispatch [${label}] timed out after ${timeoutS}s -- token telemetry lost; no steer/kill attempted`, tokenLostResult);
     }
     // Still in store -- check if updatedAt advanced (tool call still running)
     // Normalize: updatedAt may be seconds or milliseconds depending on agent framework version
@@ -1371,7 +1443,7 @@ if (sessionInternalId) {
         deliverResult(label, rExt?.lastReply || null, stExt.summary, rExt?.completion || stExt?.completion || null);
       }
       const rExt2 = dispatch('result', ['--label', label]);
-      if (rExt2?.lastReply || rExt2?.completion?.deliveryText) {
+      if (rExt2?.lastReply || hasCompletionSignal(rExt2?.completion)) {
         // deliverResult calls process.exit(0) internally
         deliverResult(label, rExt2?.lastReply || null, null, rExt2?.completion || null);
       }
@@ -1428,7 +1500,7 @@ for (const round of steerRounds) {
     deliverResult(label, r3?.lastReply || null, st2.summary, r3?.completion || st2?.completion || null);
   }
   const r3 = dispatch('result', ['--label', label]);
-  if (r3?.lastReply || r3?.completion?.deliveryText) {
+  if (r3?.lastReply || hasCompletionSignal(r3?.completion)) {
     // deliverResult calls process.exit(0) internally
     deliverResult(label, r3?.lastReply || null, null, r3?.completion || null);
   }
@@ -1443,17 +1515,16 @@ for (const round of steerRounds) {
       if (st3?.status === 'done') {
         // Check if a result was captured before marking as error
         const r4 = dispatch('result', ['--label', label]);
-        if (r4?.lastReply || r4?.completion?.deliveryText) {
+        if (r4?.lastReply || hasCompletionSignal(r4?.completion)) {
           deliverResult(label, r4?.lastReply || null, st3.summary, r4?.completion || st3?.completion || null); // deliverResult calls process.exit(0)
         }
         markLabelError(label, 'timed out -- killed after steer attempts (no result captured)');
-        process.stdout.write(`⏱ dispatch [${label}] killed after steer attempts -- no result captured\n`);
-        process.exit(1);
+        emitTimeoutOutcome(label, `⏱ dispatch [${label}] killed after steer attempts -- no result captured`, r4);
       }
     }
   }
 }
 
 markLabelError(label, `timed out after ${timeoutS}s -- killed after steer attempts`);
-process.stdout.write(`⏱ dispatch [${label}] timed out after ${timeoutS}s -- session killed after steer attempts\n`);
-process.exit(1);
+const timeoutResult = dispatch('result', ['--label', label]);
+emitTimeoutOutcome(label, `⏱ dispatch [${label}] timed out after ${timeoutS}s -- session killed after steer attempts`, timeoutResult);

package/dispatcher-strategies.js

@@ -2,6 +2,8 @@
 // Strategy pattern for dispatchJob: each execution target returns a DispatchResult,
 // and finalizeDispatch processes it uniformly.
 
+import { fileURLToPath } from 'url';
+
 /**
  * DispatchResult shape (returned by every strategy):
  * {
@@ -50,6 +52,103 @@ function safeParse(str) {
   }
 }
 
+function shellSingleQuote(value) {
+  return "'" + String(value ?? '').replaceAll("'", "'\\''") + "'";
+}
+
+function parseStructuredWatchdogPayload(text) {
+  const direct = safeParse(text);
+  if (direct && typeof direct === 'object' && !Array.isArray(direct)) return direct;
+
+  const firstBrace = text.indexOf('{');
+  const lastBrace = text.lastIndexOf('}');
+  if (firstBrace === -1 || lastBrace <= firstBrace) return null;
+
+  const candidate = text.slice(firstBrace, lastBrace + 1);
+  const parsed = safeParse(candidate);
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+}
+
+const TERMINAL_WATCHDOG_STATUSES = new Set(['done', 'error', 'interrupted', 'spawn-warning']);
+
+function normalizeWatchdogText(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function firstWatchdogText(...values) {
+  for (const value of values) {
+    const text = normalizeWatchdogText(value);
+    if (text) return text;
+  }
+  return null;
+}
+
+function resolveWatchdogTerminalPayload(stdout) {
+  const text = normalizeWatchdogText(stdout);
+  if (!text) return null;
+
+  const parsed = parseStructuredWatchdogPayload(text);
+  if (!parsed) return null;
+
+  const status = typeof parsed.status === 'string' ? parsed.status : null;
+  const terminal = parsed.terminal === true || (status ? TERMINAL_WATCHDOG_STATUSES.has(status) : false);
+  if (!terminal) return null;
+
+  const detail = firstWatchdogText(
+    parsed.deliveryText,
+    parsed.lastReply,
+    parsed.error,
+    parsed.summary,
+    parsed.completion?.deliveryText,
+    parsed.completion?.summary,
+  );
+
+  if (status && status !== 'done') {
+    return {
+      kind: 'failed',
+      detail: detail || `Task ended with status ${status}.`,
+    };
+  }
+
+  return {
+    kind: 'completed',
+    detail: detail || `Task reported terminal status ${status || 'done'}.`,
+  };
+}
+
+function buildFireAndForgetDeliveryInstruction(job) {
+  if (!job.delivery_mode || job.delivery_mode === 'none' || !job.delivery_channel || !job.delivery_to) {
+    return '';
+  }
+
+  const schedulerCliPath = fileURLToPath(new URL('./cli.js', import.meta.url));
+  const fromLabel = `scheduler-fire-and-forget:${job.id || job.name || 'job'}`;
+  const baseCmd = [
+    'node',
+    shellSingleQuote(schedulerCliPath),
+    'messages',
+    'send',
+    '--from', shellSingleQuote(fromLabel),
+    '--to', 'main',
+    '--channel', shellSingleQuote(job.delivery_channel),
+    '--delivery-to', shellSingleQuote(job.delivery_to),
+  ].join(' ');
+
+  return [
+    '\n[SYSTEM NOTE -- delivery]',
+    'When you have completed this task, queue the result through the scheduler post office.',
+    `Final result: ${baseCmd} --kind result --body "<final result>"`,
+    `Progress update: ${baseCmd} --kind status --body "<brief progress update>"`,
+    'Do NOT use the message tool, sessions_send, or any direct chat delivery.',
+    'The inbox consumer will deliver queued messages durably to the configured target.',
+    'Keep queued updates concise and actionable.',
+    'If there is nothing noteworthy to report, do not queue a message.',
+    '[END SYSTEM NOTE]\n',
+  ].join('\n');
+}
+
 function getIdentityTrustLevel(identity) {
   if (!identity || typeof identity !== 'object') return null;
   return identity.trust_level
@@ -850,16 +949,29 @@ export async function executeWatchdog(job, ctx, deps) {
     if (elapsedMin >= job.watchdog_timeout_min) timedOut = true;
   }
 
+  const terminalPayload = resolveWatchdogTerminalPayload(stdout);
+
   if (exitCode === 2) {
     result.summary = `Watchdog check failed (transient): ${stderr || stdout}`;
     result.skipDelivery = true;
     log('debug', `Watchdog check transient failure: ${job.name}`, { exitCode, stderr: stderr.slice(0, 200) });
 
-  } else if (exitCode === 0 && stdout) {
-    const completionMsg = `\u2705 [watchdog] Task "${job.watchdog_target_label}" completed -- watchdog disarmed`;
+  } else if (exitCode === 0 && terminalPayload) {
+    const completionMsg = terminalPayload.kind === 'failed'
+      ? [
+        `⚠️ [watchdog] Task "${job.watchdog_target_label}" ended with failure -- watchdog disarmed`,
+        terminalPayload.detail ? `Details: ${terminalPayload.detail}` : null,
+      ].filter(Boolean).join('\n')
+      : [
+        `\u2705 [watchdog] Task "${job.watchdog_target_label}" completed -- watchdog disarmed`,
+        terminalPayload.detail || null,
+      ].filter(Boolean).join('\n\n');
     result.summary = completionMsg;
     result.content = completionMsg;
-    log('info', `Watchdog: target completed: ${job.watchdog_target_label}`, { jobId: job.id });
+    log(terminalPayload.kind === 'failed' ? 'warn' : 'info', `Watchdog: target terminal: ${job.watchdog_target_label}`, {
+      jobId: job.id,
+      terminalKind: terminalPayload.kind,
+    });
 
     if (job.watchdog_alert_channel && job.watchdog_alert_target) {
       await handleDelivery({
@@ -909,10 +1021,12 @@ export async function executeWatchdog(job, ctx, deps) {
     result.skipDelivery = true;
 
   } else if (exitCode === 0) {
-    result.summary = `Watchdog check: target still running (${elapsedMin}min elapsed)`;
+    result.summary = stdout
+      ? `Watchdog check returned non-terminal output; target still running (${elapsedMin}min elapsed)`
+      : `Watchdog check: target still running (${elapsedMin}min elapsed)`;
     result.skipDelivery = true;
     log('debug', `Watchdog: target still running: ${job.watchdog_target_label}`, {
-      jobId: job.id, elapsedMin,
+      jobId: job.id, elapsedMin, sawStdout: Boolean(stdout),
     });
   } else {
     result.summary = `Watchdog check command returned unexpected exit code ${exitCode}`;
@@ -963,27 +1077,14 @@ export async function executeMain(job, ctx, deps) {
     ? `[SYSTEM NOTE -- model policy]\nPrefer reasoning depth: ${job.payload_thinking}.\n[END SYSTEM NOTE]\n\n`
     : '';
 
-  // Build the delivery reply-to instruction so the agent can send results
-  // back through the scheduler post office when it finishes processing.
-  let deliveryInstruction = '';
-  if (job.delivery_mode && job.delivery_mode !== 'none' && job.delivery_channel && job.delivery_to) {
-    deliveryInstruction = [
-      '\n[SYSTEM NOTE -- delivery]',
-      `When you have completed this task, send your results using the message tool.`,
-      `Channel: ${job.delivery_channel}`,
-      `Target: ${job.delivery_to}`,
-      `Keep the message concise and actionable.`,
-      `If there is nothing noteworthy to report, do not send a message.`,
-      '[END SYSTEM NOTE]\n',
-    ].join('\n');
-  }
+  const deliveryInstruction = buildFireAndForgetDeliveryInstruction(job);
 
   const prompt = `${executionNote ? `${executionNote}\n\n` : ''}${modelNote}${deliveryInstruction}${job.payload_message}`;
   await sendSystemEvent(prompt, 'now');
 
   result.summary = 'System event dispatched (fire-and-forget)';
   result.content = job.payload_message;
-  result.skipDelivery = true; // Agent handles delivery via message tool
+  result.skipDelivery = true; // Async completion is queued through the scheduler post office
   result.skipChildren = true;
   result.skipDequeue = true;
 

package/gateway.js

@@ -388,19 +388,43 @@ export function splitMessageForChannel(channel, message) {
   return [String(message ?? '')];
 }
 
-/**
- * Send a message to a Telegram/channel target via message tool.
- * Automatically resolves delivery aliases (e.g. '@team_room', 'owner_dm').
- */
-export async function deliverMessage(channel, target, message) {
-  let resolvedChannel = channel;
+export function normalizeDeliveryTarget(channel, target) {
+  let resolvedChannel = channel || null;
   let resolvedTarget = target;
 
-  // Strip channel prefix from target if present (e.g., "telegram/123456789" -> "123456789")
-  // Some jobs store the channel in the delivery_to field as "channel/id".
+  const normalizedTarget = typeof resolvedTarget === 'string' ? resolvedTarget.trim() : resolvedTarget;
+  if (!normalizedTarget) {
+    return { channel: resolvedChannel, target: normalizedTarget || null };
+  }
+
+  const prefixedMatch = normalizedTarget.match(/^([a-z0-9_-]+)([:/])(.*)$/i);
+  if (prefixedMatch) {
+    const [, prefix,, rest] = prefixedMatch;
+    if (!resolvedChannel || resolvedChannel === prefix) {
+      resolvedChannel = prefix;
+      resolvedTarget = rest;
+    }
+  }
+
   if (resolvedTarget && resolvedChannel && resolvedTarget.startsWith(resolvedChannel + '/')) {
     resolvedTarget = resolvedTarget.slice(resolvedChannel.length + 1);
   }
+  if (resolvedTarget && resolvedChannel && resolvedTarget.startsWith(resolvedChannel + ':')) {
+    resolvedTarget = resolvedTarget.slice(resolvedChannel.length + 1);
+  }
+
+  return {
+    channel: resolvedChannel,
+    target: typeof resolvedTarget === 'string' ? resolvedTarget.trim() : resolvedTarget,
+  };
+}
+
+/**
+ * Send a message to a Telegram/channel target via message tool.
+ * Automatically resolves delivery aliases (e.g. '@team_room', 'owner_dm').
+ */
+export async function deliverMessage(channel, target, message) {
+  let { channel: resolvedChannel, target: resolvedTarget } = normalizeDeliveryTarget(channel, target);
 
   // Resolve alias: try '@name' strip and bare name lookup
   if (resolvedTarget) {

package/index.d.ts

@@ -620,6 +620,7 @@ export const gateway: {
   listSessions(opts?: { activeMinutes?: number; limit?: number; kinds?: string[] }): Promise<Record<string, unknown>>;
   getAllSubAgentSessions(activeMinutes?: number): Promise<Array<Record<string, unknown>>>;
   splitMessageForChannel(channel: string, message: string): string[];
+  normalizeDeliveryTarget(channel: string | null, target: string | null): { channel: string | null; target: string | null };
   resolveDeliveryAlias(rawTarget: string): { channel: string; target: string } | null;
   deliverMessage(channel: string, target: string, message: string): Promise<DeliveryResult>;
   checkGatewayHealth(): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-scheduler",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "SQLite-backed job scheduler and workflow engine for OpenClaw agents",
   "type": "module",
   "main": "./index.js",
@@ -42,10 +42,12 @@
     "dispatch/deliver-watcher.sh",
     "dispatch/hooks.mjs",
     "dispatch/index.mjs",
+    "dispatch/message-input.mjs",
     "dispatch/README.md",
     "dispatch/watcher.mjs",
     "scripts/dispatch-cli-utils.mjs",
     "scripts/inbox-consumer.mjs",
+    "scripts/inbox-watcher-guardrail.mjs",
     "scripts/stuck-run-detector.mjs",
     "scripts/stuck-detector.sh",
     "scripts/telegram-webhook-check.mjs",