Commit a95e1c0

if (messageOverrides?.[id]) {

const payOv = existing.payload as { message?: string } | undefined;

if (payOv && typeof payOv.message === "string") {

if (payOv.message !== messageOverrides[id]) {

payOv.message = messageOverrides[id];

jobsChanged = true;

if (!normalized.includes(name)) normalized.push(name);

}

} else if (typeof existing.message === "string" && existing.message !== messageOverrides[id]) {

existing.message = messageOverrides[id];

jobsChanged = true;

if (!normalized.includes(name)) normalized.push(name);

}

// Fix: Update message to match current definition to remove obsolete command references.

// Skip when the caller supplied messageOverrides for this job — those must win over canonical text.

if (!messageOverrides?.[id]) {

const currentDef = resolveCronJob(def, pluginConfig, agentPrimary, digestWeeklyDelivery);

const defMessage = currentDef.message as string | undefined;

const payload = existing.payload as { message?: string; kind?: string } | undefined;

if (defMessage && payload && typeof payload.message === "string") {

// Extract the guard prefix from existing message (if present) and body from new definition

const guardPrefixMatch = payload.message.match(/^(GUARD CHECK.*?\n\n)/s);

const guardPrefix = guardPrefixMatch ? guardPrefixMatch[1] : "";

const defBody = defMessage.includes("GUARD CHECK")

? defMessage.replace(/^GUARD CHECK.*?\n\n/s, "")

: defMessage;

const expectedMessage = guardPrefix + defBody;

if (payload.message !== expectedMessage) {

payload.message = expectedMessage;

jobsChanged = true;

if (!normalized.includes(name)) normalized.push(name);

}

} else if (defMessage && typeof existing.message === "string") {

const guardPrefixMatch = existing.message.match(/^(GUARD CHECK.*?\n\n)/s);

const guardPrefix = guardPrefixMatch ? guardPrefixMatch[1] : "";

const defBody = defMessage.includes("GUARD CHECK")

? defMessage.replace(/^GUARD CHECK.*?\n\n/s, "")

: defMessage;

const expectedMessage = guardPrefix + defBody;

if (existing.message !== expectedMessage) {

existing.message = expectedMessage;

jobsChanged = true;

if (!normalized.includes(name)) normalized.push(name);

}

}

}

import { existsSync } from "node:fs";

import type { Chainable } from "../../shared.js";

import {

validateMaintenanceExecution,

generateCronStatusReport,

type ExitValidationResult,

} from "../../../services/cron-exit-validator.js";

export function registerValidateCronExit(hybrid: Chainable): void {

hybrid

.command("validate-cron-exit")

.description("Validate cron exit ledger (internal use by cron jobs)")

.requiredOption("--exit-path <path>", "Path to HM_EXIT file")

.option("--log-path <path>", "Path to HM_LOG file")

.requiredOption("--required-steps <steps...>", "Required step names (space-separated)")

.option("--allow-skip", "Allow skip variants (e.g., distill-skipped) to count as success")

.option("--json", "Output JSON result")

.action(

async (opts: {

exitPath: string;

logPath?: string;

requiredSteps: string[];

allowSkip?: boolean;

json?: boolean;

}) => {

const result = validateMaintenanceExecution(opts.exitPath, opts.logPath, opts.requiredSteps, !!opts.allowSkip);

if (opts.json) {

console.log(generateCronStatusReport(result));

} else {

printValidationResult(result);

}

// Exit with non-zero if maintenance failed

if (result.maintenanceStatus === "failed" || result.maintenanceStatus === "partial") {

process.exitCode = 1;

}

},

);

function printValidationResult(result: ExitValidationResult): void {

console.log(`\n=== Maintenance Validation ===`);

console.log(`Status: ${result.maintenanceStatus.toUpperCase()}`);

if (result.exitPath) {

console.log(`Exit ledger: ${result.exitPath}`);

}

if (result.logPath) {

console.log(`Log file: ${result.logPath}`);

}

console.log(`\nSteps executed: ${result.steps.length}`);

for (const step of result.steps) {

const status = step.exitCode === 0 ? "✓" : "✗";

console.log(` ${status} ${step.step} (exit=${step.exitCode})`);

}

if (result.missingSteps.length > 0) {

console.log(`\nMissing steps: ${result.missingSteps.join(", ")}`);

}

if (result.failedSteps.length > 0) {

console.log(`\nFailed steps:`);

for (const step of result.failedSteps) {

console.log(` ✗ ${step.step} (exit=${step.exitCode})`);

}

}

if (result.error) {

console.log(`\nError: ${result.error}`);

}

console.log(`\nGuard file update: ${result.guardUpdated ? "YES" : "NO"}`);

console.log(`==============================\n`);

import { registerValidateCronExit } from "./manage/register-validate-cron-exit.js";

registerValidateCronExit(mem);

As of this fix, hybrid-memory cron jobs now validate that all required maintenance steps complete successfully before reporting `status: ok`. This prevents the dangerous situation where cron state shows "healthy" while maintenance is actually failing.

Previously, cron jobs could report `status: ok` even when:

- Required maintenance steps failed (non-zero exit codes)

- Steps were missing from the exit ledger

- Commands were invalid (`unknown command` errors)

- Only partial work completed (e.g., only `prune` ran, not `distill`/`extract`/etc.)

- Guard files weren't updated due to failures

This happened because OpenClaw cron treated "agent produced a response" as success, regardless of what that response contained.

New module that validates maintenance execution by:

- Parsing HM_EXIT file for all step results

- Checking for `unknown command` errors in HM_LOG

- Validating all required steps are present with `exit=0`

- Supporting skip variants (e.g., `distill-skipped` when config disabled)

- Returning structured status: `success`, `partial`, or `failed`

Enhanced templates now include:

- Explicit validation instructions for agents

- List of required steps that must complete

- Clear success criteria (all steps present with `exit=0`)

- Mandatory guard update only after successful validation

- Structured reply format for debugging

When `normalizeExisting=true` (e.g., during `verify --fix`):

- Updates existing cron job messages to match current definitions

- Removes obsolete command references (e.g., `consolidate-episodes`)

- Preserves guard prefixes while updating orchestration instructions

- Ensures all jobs use latest validation rules

New internal command for validating cron execution:

openclaw hybrid-mem validate-cron-exit \

--exit-path ~/.openclaw/logs/cron-hybrid-mem/nightly-memory-sweep-*.exit.txt \

--log-path ~/.openclaw/logs/cron-hybrid-mem/nightly-memory-sweep-*.log \

--required-steps prune distill extract-daily resolve-contradictions enrich-entities \

--allow-skip

Returns exit code 1 if validation fails.

All required steps present with `exit=0`:

- `maintenanceStatus`: `success`

- `guardUpdated`: `true`

- Cron status: `ok`

Any step missing or non-zero exit:

- `maintenanceStatus`: `failed`

- `guardUpdated`: `false`

- Cron status should be: `error` (agent must signal failure)

When the exit file exists but **none** of the required steps appear in the ledger (including an empty file), validation returns **`failed`**. That pattern matches an abort before the first `hm_step` wrote to `HM_EXIT`, and must not be treated as a successful skip.

Use config skip variants (e.g. `distill-skipped` with `--allow-skip`) when a step is intentionally omitted.

Some steps missing:

- `maintenanceStatus`: `partial`

- `guardUpdated`: `false`

- Cron status should be: `error`

When a feature is disabled in config, the cron message instructs the agent to replace that step with a skip variant:

hm_step "distill-skipped" bash -c 'echo distill disabled; exit 0'

With `allowSkip=true`, the validator accepts these skip variants as satisfying the required step.

Existing installations with old cron job definitions will be updated automatically when:

1. User runs `openclaw hybrid-mem verify --fix`

2. Plugin upgrade triggers `ensureMaintenanceCronJobs(..., { normalizeExisting: true })`

3. Gateway restart (sync from persistent guard files)

The message normalization preserves the guard prefix while updating the orchestration body to include validation rules.

Comprehensive tests in `tests/cron-exit-validator.test.ts`:

- Exit line parsing (valid, invalid, non-zero codes)

- Unknown command detection

- Success/failed/partial status determination (all-required-missing → failed)

- Skip variant handling

- Missing file handling

All 14 tests pass.

✅ Required-step failure makes cron run non-OK

✅ Unknown command makes cron run non-OK

✅ Missing required steps treated as failure

✅ Empty or incomplete ledgers do not produce a false `ok` / skip outcome

✅ Message normalization removes obsolete commands

✅ Validation instructions embedded in all cron messages

To fully close the loop, OpenClaw cron core would need to:

1. Accept structured status from agent (not just text response)

2. Map `maintenanceStatus` → cron `status` (`success`→`ok`, `failed`/`partial`→`error`)

3. Update `lastRunStatus` and `consecutiveErrors` based on maintenance outcome

Until then, agents must signal failure explicitly (e.g., by mentioning "FAILED" in response or exiting with error) when validation fails.