create-principles-disciple 1.86.0 → 1.87.0

package/core/dist/runtime-v2/__tests__/internalization-integrity-remediation.test.js

@@ -42,12 +42,18 @@ describe('InternalizationIntegrityRemediation', () => {
       CREATE TABLE IF NOT EXISTS runs (
         run_id TEXT PRIMARY KEY,
         task_id TEXT NOT NULL,
-        status TEXT NOT NULL,
+        runtime_kind TEXT NOT NULL DEFAULT 'openclaw',
+        execution_status TEXT NOT NULL DEFAULT 'queued',
         started_at TEXT,
-        completed_at TEXT,
-        output_json TEXT,
-        error_json TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        ended_at TEXT,
+        reason TEXT,
+        output_ref TEXT,
+        input_payload TEXT,
+        output_payload TEXT,
+        error_category TEXT,
+        attempt_number INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
       );
     `);
         db.close();
@@ -76,6 +82,22 @@ describe('InternalizationIntegrityRemediation', () => {
         d.close();
         return row?.[field] ?? null;
     }
+    function getRunField(runId, field) {
+        const d = new Database(dbPath);
+        const row = d.prepare(`SELECT ${field} FROM runs WHERE run_id = ?`).get(runId);
+        d.close();
+        return row?.[field] ?? null;
+    }
+    function insertRun(opts) {
+        const d = new Database(dbPath);
+        const now = new Date().toISOString();
+        // runtime_kind defaults to 'openclaw' (a valid RuntimeKindSchema enum value)
+        // so the row passes schema validation and is NOT flagged as malformed by
+        // detectMalformedRuns. Tests that need a malformed row use insertMalformedRunRow.
+        d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, execution_status, started_at, attempt_number, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(opts.runId, opts.taskId, opts.runtimeKind ?? 'openclaw', opts.executionStatus, now, opts.attemptNumber ?? 1, now, now);
+        d.close();
+    }
     function findAction(actions, taskId, type) {
         return actions.find(a => a.taskId === taskId && a.type === type);
     }
@@ -185,6 +207,7 @@ describe('InternalizationIntegrityRemediation', () => {
         });
         it('does not touch non-dreamer tasks', () => {
             insertTask({ taskId: 'diagnostician-001', taskKind: 'diagnostician', status: 'succeeded' });
+            insertRun({ runId: 'run-diag-1', taskId: 'diagnostician-001', executionStatus: 'succeeded' });
             const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
             const result = remediation.repair({ dryRun: false });
             expect(getTaskField('diagnostician-001', 'status')).toBe('succeeded');
@@ -193,6 +216,7 @@ describe('InternalizationIntegrityRemediation', () => {
         it('does not touch dreamer tasks with artifact and successor', () => {
             insertTask({ taskId: 'dreamer-ok', taskKind: 'dreamer', status: 'succeeded' });
             insertArtifact({ artifactId: 'art-ok', sourceTaskId: 'dreamer-ok', kind: 'principle', content: '{"valid":true}' });
+            insertRun({ runId: 'run-dream-ok', taskId: 'dreamer-ok', executionStatus: 'succeeded' });
             insertTask({
                 taskId: 'philosopher-ok',
                 taskKind: 'philosopher',
@@ -214,5 +238,501 @@ describe('InternalizationIntegrityRemediation', () => {
             expect(action?.newStatus).toBe('retry_wait');
         });
     });
+    describe('lease_stuck and running_run_stuck', () => {
+        it('dry-run reports lease_stuck as force_expire_lease action', () => {
+            const pastDate = new Date(Date.now() - 60000).toISOString();
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-task', 'dreamer', 'auto-consumer', pastDate);
+            insertRun({ runId: 'run-stuck', taskId: 'stuck-task', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            const action = findAction(result.actions, 'stuck-task', 'lease_stuck');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('force_expire_lease');
+            expect(action?.previousStatus).toBe('leased');
+            expect(action?.newStatus).toBe('pending');
+            // Verify DB not modified
+            expect(getTaskField('stuck-task', 'status')).toBe('leased');
+        });
+        it('confirm force-expires stuck lease and marks run as failed', () => {
+            const pastDate = new Date(Date.now() - 60000).toISOString();
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-task2', 'dreamer', 'auto-consumer', pastDate);
+            insertRun({ runId: 'run-stuck2', taskId: 'stuck-task2', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            // Task should be force-expired to pending
+            expect(getTaskField('stuck-task2', 'status')).toBe('pending');
+            expect(getTaskField('stuck-task2', 'lease_owner')).toBeNull();
+            // Run should be marked as failed
+            expect(getRunField('run-stuck2', 'execution_status')).toBe('failed');
+            expect(getRunField('run-stuck2', 'error_category')).toBe('lease_expired');
+            const action = findAction(result.actions, 'stuck-task2', 'lease_stuck');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('force_expire_lease');
+        });
+        it('is idempotent - second confirm skips already repaired lease_stuck', () => {
+            const pastDate = new Date(Date.now() - 60000).toISOString();
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-idem', 'dreamer', 'auto-consumer', pastDate);
+            insertRun({ runId: 'run-idem', taskId: 'stuck-idem', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result1 = remediation.repair({ dryRun: false });
+            const result2 = remediation.repair({ dryRun: false });
+            expect(result1.repairedCount).toBeGreaterThan(0);
+            expect(result2.repairedCount).toBe(0);
+            const secondActions = result2.actions.filter(a => a.type === 'lease_stuck');
+            expect(secondActions.every(a => a.recommendedAction === 'already_repaired')).toBe(true);
+        });
+        it('dry-run reports running_run_stuck as mark_run_failed', () => {
+            // Task is succeeded but run is still running — orphaned run
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts) VALUES (?, ?, 'succeeded', 1, 3)").run('orphan-task', 'dreamer');
+            insertRun({ runId: 'run-orphan', taskId: 'orphan-task', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            const action = findAction(result.actions, 'orphan-task', 'running_run_stuck');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('mark_run_failed');
+            expect(action?.previousStatus).toBe('running');
+            expect(action?.newStatus).toBe('failed');
+            // Verify DB not modified
+            expect(getRunField('run-orphan', 'execution_status')).toBe('running');
+        });
+        it('confirm marks orphaned running run as failed', () => {
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts) VALUES (?, ?, 'failed', 1, 3)").run('orphan-task2', 'dreamer');
+            insertRun({ runId: 'run-orphan2', taskId: 'orphan-task2', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            // Run should be marked as failed
+            expect(getRunField('run-orphan2', 'execution_status')).toBe('failed');
+            const action = findAction(result.actions, 'orphan-task2', 'running_run_stuck');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('mark_run_failed');
+            expect(action?.reason).toContain('recovery repair');
+        });
+        it('skips running_run_stuck when run is already failed', () => {
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts) VALUES (?, ?, 'failed', 1, 3)").run('orphan-task3', 'dreamer');
+            insertRun({ runId: 'run-orphan3', taskId: 'orphan-task3', executionStatus: 'failed' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            expect(result.actions.filter(a => a.type === 'running_run_stuck').length).toBe(0);
+        });
+        it('combines lease_stuck + dreamer repair in one pass', () => {
+            // A stuck lease + a succeeded dreamer with missing artifact
+            const pastDate = new Date(Date.now() - 60000).toISOString();
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-combo', 'dreamer', 'auto-consumer', pastDate);
+            insertRun({ runId: 'run-combo', taskId: 'stuck-combo', executionStatus: 'running' });
+            insertTask({ taskId: 'dreamer-combo', taskKind: 'dreamer', status: 'succeeded' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            expect(getTaskField('stuck-combo', 'status')).toBe('pending');
+            expect(getRunField('run-combo', 'execution_status')).toBe('failed');
+            expect(getTaskField('dreamer-combo', 'status')).toBe('retry_wait');
+            const leaseAction = findAction(result.actions, 'stuck-combo', 'lease_stuck');
+            expect(leaseAction).toBeDefined();
+            expect(leaseAction?.recommendedAction).toBe('force_expire_lease');
+            const dreamerAction = findAction(result.actions, 'dreamer-combo', 'missing_dreamer_pi_artifact');
+            expect(dreamerAction).toBeDefined();
+            expect(dreamerAction?.recommendedAction).toBe('requeue');
+        });
+        it('refuses to repair unsafe stuck lease with null or unparseable lease_expires_at', () => {
+            const d = new Database(dbPath);
+            // null expires_at
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, NULL)").run('unsafe-null-task', 'dreamer', 'auto-consumer');
+            // unparseable expires_at
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('unsafe-bad-task', 'dreamer', 'auto-consumer', 'not-a-date');
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            // DB should not be changed for these tasks
+            expect(getTaskField('unsafe-null-task', 'status')).toBe('leased');
+            expect(getTaskField('unsafe-bad-task', 'status')).toBe('leased');
+            // Actions should refuse repair and warnings should be generated
+            const actionNull = findAction(result.actions, 'unsafe-null-task', 'lease_stuck');
+            expect(actionNull).toBeDefined();
+            expect(actionNull?.action).toBe('refuse_repair');
+            expect(actionNull?.recommendedAction).toBe('manual_intervention');
+            expect(actionNull?.reason).toContain('missing/null');
+            const actionBad = findAction(result.actions, 'unsafe-bad-task', 'lease_stuck');
+            expect(actionBad).toBeDefined();
+            expect(actionBad?.action).toBe('refuse_repair');
+            expect(actionBad?.recommendedAction).toBe('manual_intervention');
+            expect(actionBad?.reason).toContain('unparseable');
+            expect(result.warnings.length).toBe(2);
+            expect(result.safeToConfirm).toBe(false);
+        });
+    });
+    // ── Malformed run row quarantine (PRI-392 follow-up) ────────────────────────
+    describe('malformed run row quarantine', () => {
+        /**
+         * Insert a schema-malformed run row via raw SQL. runtime_kind='config'
+         * is not in the RuntimeKindSchema enum, so Value.Check(RunRecordSchema)
+         * fails — exactly the failure mode that throws MalformedRunError from
+         * SqliteRunStore and historically blocked runner recovery.
+         */
+        function insertMalformedRunRow(runId, taskId) {
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'config', ?, 1, 'queued', ?, ?)`).run(runId, taskId, now, now, now);
+            d.close();
+        }
+        it('dry-run detects malformed run row but does NOT mutate DB', () => {
+            // Need a task row so detection has something to attribute.
+            insertTask({ taskId: 'malf-task-1', taskKind: 'dreamer', status: 'succeeded' });
+            insertMalformedRunRow('run-malf-1', 'malf-task-1');
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            expect(result.dryRun).toBe(true);
+            const action = findAction(result.actions, 'malf-task-1', 'malformed_run_row');
+            expect(action).toBeDefined();
+            expect(action?.targetId).toBe('run-malf-1');
+            expect(action?.recommendedAction).toBe('quarantine_malformed_run');
+            expect(action?.reason).toContain('schema validation');
+            expect(action?.newStatus).toBe('failed');
+            // Dry-run must NOT mutate the DB.
+            expect(getRunField('run-malf-1', 'execution_status')).toBe('queued');
+        });
+        it('confirm refuses to repair malformed run row when required fields are unrecoverable', () => {
+            insertTask({ taskId: 'malf-task-2', taskKind: 'dreamer', status: 'succeeded' });
+            insertMalformedRunRow('run-malf-2', 'malf-task-2');
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            // runtime_kind='config' fails RuntimeKindSchema validation in
+            // safeUpdateRunRow pre-write check → refuse_repair with manual_intervention
+            const action = findAction(result.actions, 'malf-task-2', 'malformed_run_row');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('manual_intervention');
+            expect(action?.action).toBe('refuse_repair');
+            // Row must NOT be mutated (we refused, not quarantined)
+            expect(getRunField('run-malf-2', 'execution_status')).toBe('queued');
+            expect(getRunField('run-malf-2', 'error_category')).toBeNull();
+            // Warnings must be emitted explaining the refusal
+            expect(result.warnings.length).toBeGreaterThanOrEqual(1);
+        });
+        it('confirm quarantines malformed run row when optional fields are invalid (recoverable)', () => {
+            insertTask({ taskId: 'malf-task-6', taskKind: 'dreamer', status: 'succeeded' });
+            // Insert a row where required fields (task_id, runtime_kind, started_at,
+            // created_at, attempt_number) are VALID, but execution_status is invalid.
+            // rowToRecord fails because execution_status='invalid_status' is not a
+            // valid RunExecutionStatus → detectMalformedRuns catches it.
+            // safeUpdateRunRow replaces execution_status with 'failed' → quarantine succeeds.
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'openclaw', ?, 1, 'invalid_status', ?, ?)`).run('run-malf-6', 'malf-task-6', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            expect(result.repairedCount).toBeGreaterThanOrEqual(1);
+            const action = findAction(result.actions, 'malf-task-6', 'malformed_run_row');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('quarantine_malformed_run');
+            // Row must be quarantined
+            expect(getRunField('run-malf-6', 'execution_status')).toBe('failed');
+            expect(getRunField('run-malf-6', 'error_category')).toBe('storage_unavailable');
+            const reason = getRunField('run-malf-6', 'reason');
+            expect(String(reason)).toContain('quarantined');
+            // Never marked succeeded
+            expect(getRunField('run-malf-6', 'execution_status')).not.toBe('succeeded');
+        });
+        it('is idempotent — second confirm skips already-quarantined rows', () => {
+            insertTask({ taskId: 'malf-task-3', taskKind: 'dreamer', status: 'succeeded' });
+            // Use recoverable malformed row (invalid execution_status, valid runtime_kind)
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'openclaw', ?, 1, 'invalid_status', ?, ?)`).run('run-malf-3', 'malf-task-3', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result1 = remediation.repair({ dryRun: false });
+            const result2 = remediation.repair({ dryRun: false });
+            // First run quarantines the row.
+            const action1 = findAction(result1.actions, 'malf-task-3', 'malformed_run_row');
+            expect(action1?.recommendedAction).toBe('quarantine_malformed_run');
+            // Second run: row is already failed → already_repaired, no new mutation.
+            const action2 = findAction(result2.actions, 'malf-task-3', 'malformed_run_row');
+            expect(action2?.recommendedAction).toBe('already_repaired');
+            // repairedCount on the second pass must not count the already-failed row.
+            const secondQuarantineActions = result2.actions.filter((a) => a.type === 'malformed_run_row' && a.recommendedAction === 'quarantine_malformed_run');
+            expect(secondQuarantineActions.length).toBe(0);
+        });
+        it('valid run rows are NOT flagged as malformed', () => {
+            insertTask({ taskId: 'malf-task-4', taskKind: 'dreamer', status: 'succeeded' });
+            // Insert a fully-valid run row.
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'openclaw', ?, 1, 'succeeded', ?, ?)`).run('run-valid-4', 'malf-task-4', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            const action = findAction(result.actions, 'malf-task-4', 'malformed_run_row');
+            expect(action).toBeUndefined();
+        });
+    });
+    describe('task_succeeded_no_succeeded_run', () => {
+        it('dry-run reports task_succeeded_no_succeeded_run but does not mutate DB', () => {
+            insertTask({ taskId: 'task-no-run-1', taskKind: 'diagnostician', status: 'succeeded' });
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            const action = findAction(result.actions, 'task-no-run-1', 'task_succeeded_no_succeeded_run');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('supplement_succeeded_run');
+            // Check that DB is not mutated (no run inserted)
+            const d = new Database(dbPath);
+            const row = d.prepare("SELECT 1 FROM runs WHERE task_id = 'task-no-run-1'").get();
+            d.close();
+            expect(row).toBeUndefined();
+        });
+        it('confirm supplements a canonical succeeded run and is schema-valid', () => {
+            insertTask({ taskId: 'task-no-run-2', taskKind: 'diagnostician', status: 'succeeded' });
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            expect(result.repairedCount).toBe(1);
+            const action = findAction(result.actions, 'task-no-run-2', 'task_succeeded_no_succeeded_run');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('supplement_succeeded_run');
+            // Check that DB contains a valid succeeded run
+            const d = new Database(dbPath);
+            const run = d.prepare("SELECT * FROM runs WHERE task_id = 'task-no-run-2' AND execution_status = 'succeeded'").get();
+            d.close();
+            expect(run).toBeDefined();
+            expect(run?.runtime_kind).toBe('openclaw');
+            expect(run?.attempt_number).toBe(1);
+            expect(run?.reason).toContain('Supplemented');
+        });
+        it('is idempotent — second confirm skips already-supplemented runs', () => {
+            insertTask({ taskId: 'task-no-run-3', taskKind: 'diagnostician', status: 'succeeded' });
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result1 = remediation.repair({ dryRun: false });
+            const result2 = remediation.repair({ dryRun: false });
+            expect(result1.repairedCount).toBe(1);
+            expect(result2.repairedCount).toBe(0);
+            const action = findAction(result2.actions, 'task-no-run-3', 'task_succeeded_no_succeeded_run');
+            expect(action).toBeUndefined();
+        });
+        it('dry-run reports supplement_succeeded_run when succeeded task has only malformed succeeded run rows', () => {
+            insertTask({ taskId: 'task-malf-run', taskKind: 'diagnostician', status: 'succeeded' });
+            // Insert a schema-invalid succeeded run (runtime_kind='config' not in RuntimeKindSchema)
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'config', ?, 1, 'succeeded', ?, ?)`).run('run-schema-invalid', 'task-malf-run', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // The malformed succeeded run is not a valid succeeded run, so
+            // supplement_succeeded_run should be shown
+            const action = findAction(result.actions, 'task-malf-run', 'task_succeeded_no_succeeded_run');
+            expect(action).toBeDefined();
+            expect(action?.recommendedAction).toBe('supplement_succeeded_run');
+            // DB must NOT be mutated (dry-run)
+            const d2 = new Database(dbPath);
+            const rows = d2.prepare("SELECT execution_status FROM runs WHERE task_id = 'task-malf-run'").all();
+            expect(rows).toHaveLength(1);
+            expect(rows[0]?.execution_status).toBe('succeeded');
+            d2.close();
+        });
+    });
+    // ── Schema Validation Boundary Tests (PRI-396 follow-up) ───────────────────────
+    describe('schema validation boundary conditions', () => {
+        /**
+         * Insert a run row with multiple schema violations.
+         * Tests that detection correctly identifies all issues.
+         */
+        function insertMultiMalformedRunRow(runId, taskId) {
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            // Multiple violations: invalid runtime_kind AND invalid execution_status
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'invalid_kind', ?, -1, 'invalid_status', ?, ?)`).run(runId, taskId, now, now, now);
+            d.close();
+        }
+        it('detects run row with multiple schema violations', () => {
+            insertTask({ taskId: 'multi-malf-task', taskKind: 'dreamer', status: 'succeeded' });
+            insertMultiMalformedRunRow('run-multi-malf', 'multi-malf-task');
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            const action = findAction(result.actions, 'multi-malf-task', 'malformed_run_row');
+            expect(action).toBeDefined();
+            expect(action?.reason).toContain('schema validation');
+        });
+        it('handles run row with null required fields', () => {
+            insertTask({ taskId: 'null-fields-task', taskKind: 'dreamer', status: 'succeeded' });
+            const d = new Database(dbPath);
+            // Provide valid NOT NULL values (runtime_kind='invalid_null_kind', attempt_number=0)
+            // so the INSERT succeeds, but started_at=NULL triggers detection.
+            // runtime_kind is invalid (not in RuntimeKindSchema) → malformed.
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'invalid_null_kind', NULL, 0, 'queued', ?, ?)`).run('run-null-fields', 'null-fields-task', new Date().toISOString(), new Date().toISOString());
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // 'invalid_null_kind' is not in RuntimeKindSchema → malformed
+            const action = findAction(result.actions, 'null-fields-task', 'malformed_run_row');
+            expect(action).toBeDefined();
+            expect(action?.reason).toContain('schema validation');
+        });
+        it('handles run row with wrong data types', () => {
+            insertTask({ taskId: 'wrong-type-task', taskKind: 'dreamer', status: 'succeeded' });
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            // SQLite will coerce types, but we test the detection logic
+            // Use valid attempt_number (integer) to avoid SQL error
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'openclaw', ?, 1, 'invalid_status', ?, ?)`).run('run-wrong-type', 'wrong-type-task', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Should detect the malformed row (invalid execution_status)
+            const action = findAction(result.actions, 'wrong-type-task', 'malformed_run_row');
+            expect(action).toBeDefined();
+        });
+        it('handles empty run_id', () => {
+            insertTask({ taskId: 'empty-run-id-task', taskKind: 'dreamer', status: 'succeeded' });
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'openclaw', ?, 1, 'queued', ?, ?)`).run('', 'empty-run-id-task', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Empty run_id should be detected as malformed
+            expect(result.actions.some(a => a.type === 'malformed_run_row')).toBe(true);
+        });
+        it('handles run row with extra unknown columns (SQLite flexible schema)', () => {
+            insertTask({ taskId: 'extra-cols-task', taskKind: 'dreamer', status: 'succeeded' });
+            // Add an extra column and insert data
+            const d = new Database(dbPath);
+            d.exec(`ALTER TABLE runs ADD COLUMN extra_unknown TEXT`);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT OR REPLACE INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at, extra_unknown)
+         VALUES (?, ?, 'openclaw', ?, 1, 'succeeded', ?, ?, 'extra_value')`).run('run-extra-cols', 'extra-cols-task', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Extra columns should not cause detection (schema validation ignores unknown fields)
+            const action = findAction(result.actions, 'extra-cols-task', 'malformed_run_row');
+            expect(action).toBeUndefined();
+        });
+        it('handles concurrent malformed run rows for same task', () => {
+            insertTask({ taskId: 'concurrent-malf-task', taskKind: 'dreamer', status: 'succeeded' });
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            // Insert multiple malformed runs for same task
+            d.prepare(`INSERT INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'invalid_kind', ?, 1, 'queued', ?, ?)`).run('run-concurrent-1', 'concurrent-malf-task', now, now, now);
+            d.prepare(`INSERT INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'invalid_kind', ?, 2, 'running', ?, ?)`).run('run-concurrent-2', 'concurrent-malf-task', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Should detect both malformed runs
+            const malformedActions = result.actions.filter(a => a.type === 'malformed_run_row' && a.taskId === 'concurrent-malf-task');
+            expect(malformedActions.length).toBeGreaterThanOrEqual(2);
+        });
+        it('handles valid run row after malformed row is quarantined', () => {
+            insertTask({ taskId: 'valid-after-malf-task', taskKind: 'dreamer', status: 'succeeded' });
+            // First insert a recoverable malformed row
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            d.prepare(`INSERT INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'openclaw', ?, 1, 'invalid_status', ?, ?)`).run('run-malf-then-valid', 'valid-after-malf-task', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result1 = remediation.repair({ dryRun: false });
+            // First run quarantines the malformed row
+            expect(result1.repairedCount).toBeGreaterThanOrEqual(1);
+            // Now insert a valid run row
+            insertRun({ runId: 'run-valid-after', taskId: 'valid-after-malf-task', executionStatus: 'succeeded' });
+            // Second repair should not flag the valid run
+            const result2 = remediation.repair({ dryRun: true });
+            const validRunAction = result2.actions.find(a => a.targetId === 'run-valid-after' && a.type === 'malformed_run_row');
+            expect(validRunAction).toBeUndefined();
+        });
+        it('handles task with only malformed runs (no valid runs)', () => {
+            insertTask({ taskId: 'only-malf-runs-task', taskKind: 'dreamer', status: 'succeeded' });
+            const d = new Database(dbPath);
+            const now = new Date().toISOString();
+            // Insert only malformed runs
+            d.prepare(`INSERT INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'invalid_kind', ?, 1, 'queued', ?, ?)`).run('run-only-malf-1', 'only-malf-runs-task', now, now, now);
+            d.prepare(`INSERT INTO runs (run_id, task_id, runtime_kind, started_at, attempt_number, execution_status, created_at, updated_at)
+         VALUES (?, ?, 'invalid_kind', ?, 2, 'running', ?, ?)`).run('run-only-malf-2', 'only-malf-runs-task', now, now, now);
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Should also flag task_succeeded_no_succeeded_run since no valid succeeded run exists
+            const noSucceededAction = findAction(result.actions, 'only-malf-runs-task', 'task_succeeded_no_succeeded_run');
+            expect(noSucceededAction).toBeDefined();
+        });
+    });
+    // ── Additional Lease Stuck Boundary Tests ─────────────────────────────────────
+    describe('lease_stuck additional boundary conditions', () => {
+        it('handles lease with future expiry date (not stuck)', () => {
+            const futureDate = new Date(Date.now() + 600000).toISOString(); // 10 minutes in future
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('future-lease-task', 'dreamer', 'auto-consumer', futureDate);
+            insertRun({ runId: 'run-future', taskId: 'future-lease-task', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Future lease should NOT be flagged as stuck
+            const action = findAction(result.actions, 'future-lease-task', 'lease_stuck');
+            expect(action).toBeUndefined();
+        });
+        it('handles lease exactly at boundary (just expired)', () => {
+            const boundaryDate = new Date(Date.now() - 1).toISOString(); // 1ms ago
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('boundary-lease-task', 'dreamer', 'auto-consumer', boundaryDate);
+            insertRun({ runId: 'run-boundary', taskId: 'boundary-lease-task', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Just expired should be flagged as stuck
+            const action = findAction(result.actions, 'boundary-lease-task', 'lease_stuck');
+            expect(action).toBeDefined();
+        });
+        it('handles lease stuck without associated run', () => {
+            const pastDate = new Date(Date.now() - 60000).toISOString();
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-no-run-task', 'dreamer', 'auto-consumer', pastDate);
+            // No run inserted
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: true });
+            // Should still be flagged as stuck lease
+            const action = findAction(result.actions, 'stuck-no-run-task', 'lease_stuck');
+            expect(action).toBeDefined();
+        });
+        it('handles multiple stuck leases in single pass', () => {
+            const pastDate = new Date(Date.now() - 60000).toISOString();
+            const d = new Database(dbPath);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-multi-1', 'dreamer', 'auto-consumer', pastDate);
+            d.prepare("INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, lease_owner, lease_expires_at) VALUES (?, ?, 'leased', 1, 3, ?, ?)").run('stuck-multi-2', 'dreamer', 'auto-consumer', pastDate);
+            insertRun({ runId: 'run-stuck-multi-1', taskId: 'stuck-multi-1', executionStatus: 'running' });
+            insertRun({ runId: 'run-stuck-multi-2', taskId: 'stuck-multi-2', executionStatus: 'running' });
+            d.close();
+            const remediation = new InternalizationIntegrityRemediation({ workspaceDir: tmpDir });
+            const result = remediation.repair({ dryRun: false });
+            // Both should be repaired
+            expect(getTaskField('stuck-multi-1', 'status')).toBe('pending');
+            expect(getTaskField('stuck-multi-2', 'status')).toBe('pending');
+            const stuckActions = result.actions.filter(a => a.type === 'lease_stuck');
+            expect(stuckActions.length).toBe(2);
+        });
+    });
 });
 //# sourceMappingURL=internalization-integrity-remediation.test.js.map