@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-provider-scheduler.js

@@ -0,0 +1,689 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const root = __dirname;
+const fixturesRoot = path.join(root, "test-fixtures", "migrations");
+
+function readFixture(name, file = "jobs.json") {
+  return JSON.parse(fs.readFileSync(path.join(fixturesRoot, name, file), "utf8"));
+}
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+function nextTurn() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+function migrationProbe(jobsApi) {
+  const defaults = {
+    defaultCanonicalUserId: "telegram:fixture",
+    defaultChannelId: "fixture-channel",
+    defaultAdapter: "telegram-fixture",
+    defaultAdapterType: "telegram",
+    now: () => 1_720_000_000_000,
+    occurrenceIdFactory: (job) => `occ-${job.id}`,
+  };
+
+  const claudeLegacy = readFixture("claude-only").map((job) => ({ ...job, fireAt: 1_720_000_100_000 }));
+  const claude = jobsApi.migrateJobsDocument(claudeLegacy, defaults);
+  assert.strictEqual(claude.schemaVersion, jobsApi.JOBS_SCHEMA_VERSION);
+  assert.strictEqual(claude.jobs.length, 1);
+  assert.strictEqual(claude.jobs[0].provider, "claude");
+  assert.strictEqual(claude.jobs[0].sessionId, "claude-session-alpha");
+  assert.strictEqual(claude.jobs[0].project, "alpha");
+  assert.strictEqual(claude.jobs[0].canonicalUserId, "telegram:fixture");
+  assert.strictEqual(claude.jobs[0].occurrenceId, "occ-job-claude");
+  assert.ok(!Object.prototype.hasOwnProperty.call(claude.jobs[0], "sessionKey"));
+
+  const codexLegacy = readFixture("dual-provider").map((job) => ({ ...job, schedule: "0 9 * * 1-5" }));
+  const codex = jobsApi.migrateJobsDocument(codexLegacy, defaults);
+  assert.strictEqual(codex.jobs[0].provider, "codex");
+  assert.strictEqual(codex.jobs[0].sessionId, "codex-thread-parity");
+
+  const cursor = jobsApi.migrateJobsDocument(readFixture("cursor-selected"), defaults);
+  assert.deepStrictEqual(cursor.jobs, []);
+  assert.strictEqual(cursor.archived.length, 1);
+  assert.strictEqual(cursor.archived[0].id, "job-cursor");
+  assert.strictEqual(cursor.archived[0].provider, "cursor");
+  assert.strictEqual(cursor.archived[0].sessionId, "cursor-session-unresolved");
+  assert.strictEqual(cursor.archived[0].status, "archived");
+  assert.strictEqual(cursor.archived[0].disabled, true);
+  assert.match(cursor.archived[0].archiveReason, /removed provider/i);
+  assert.ok(!cursor.archived.some((job) => ["claude", "codex"].includes(job.provider)), "Cursor work must not be reassigned");
+
+  const missing = jobsApi.migrateJobsDocument(readFixture("missing-project"), defaults);
+  assert.deepStrictEqual(missing.jobs, []);
+  assert.strictEqual(missing.archived[0].id, "orphan-job");
+  assert.match(missing.archived[0].archiveReason, /project/i);
+
+  const multi = jobsApi.migrateJobsDocument(readFixture("multi-user").map((job) => (
+    job.kind === "wakeup" ? { ...job, fireAt: 1_720_000_100_000 } : { ...job, schedule: "0 9 * * 1-5" }
+  )), defaults);
+  assert.deepStrictEqual(multi.jobs.map((job) => job.canonicalUserId), ["telegram:100", "person@example.test"]);
+
+  const malformed = jobsApi.migrateJobsDocument([], {
+    ...defaults,
+    malformedSource: { path: "jobs.json", size: 42, sha256: "fixture-hash" },
+  });
+  assert.strictEqual(malformed.archived.length, 1);
+  assert.match(malformed.archived[0].archiveReason, /malformed/i);
+  assert.deepStrictEqual(malformed.archived[0].sourceSnapshot, { path: "jobs.json", size: 42, sha256: "fixture-hash" });
+
+  const rerun = jobsApi.migrateJobsDocument(cursor, defaults);
+  assert.deepStrictEqual(rerun, cursor, "jobs migration must be idempotent");
+}
+
+function migrationIntegrationProbe(jobsApi, migrationApi) {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-jobs-migration-"));
+  try {
+    const configDir = path.join(temp, "config");
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.cpSync(path.join(fixturesRoot, "cursor-selected"), configDir, { recursive: true });
+    const jobsFile = path.join(configDir, "jobs.json");
+    const originalJobs = fs.readFileSync(jobsFile);
+    const sources = migrationApi.defaultMigrationSources({ configDir });
+    const snapshot = migrationApi.ensureMigrationSnapshot({ configDir, sources });
+    const store = jobsApi.createJobsStore({
+      jobsFile,
+      configDir,
+      sources,
+      now: () => 1_720_000_000_000,
+      occurrenceIdFactory: (job) => `occ-${job.id}`,
+      defaults: {
+        canonicalUserId: "telegram:fixture",
+        channelId: "fixture-channel",
+        adapter: "telegram-fixture",
+        adapterType: "telegram",
+      },
+    });
+    const migrated = store.ensureMigrated();
+    assert.strictEqual(migrated.schemaVersion, jobsApi.JOBS_SCHEMA_VERSION);
+    assert.strictEqual(store.listAll().length, 0);
+    assert.strictEqual(store.listArchived()[0].id, "job-cursor");
+    assert.ok(store.listArchived().some((job) => job.id === "legacy-cron" && job.disabled === true),
+      "legacy crons are archived by jobs migration before readiness activation");
+    assert.deepStrictEqual(migrated.legacyCronMigration.recordCount, 1);
+    assert.strictEqual(migrated.legacyCronMigration.status, "archived");
+    assert.ok(migrationApi.readMigrationJournal(configDir).components.jobs);
+    assert.deepStrictEqual(
+      fs.readFileSync(path.join(snapshot.snapshotDir, "originals", "jobs.json")),
+      originalJobs,
+      "verified snapshot must retain the byte-for-byte legacy jobs source",
+    );
+
+    assert.ok(store.listArchived().every((job) => !job.announcedAt), "archived jobs start unannounced");
+    const announcedCount = store.markArchivedAnnounced(store.listArchived().map((job) => job.id));
+    assert.ok(announcedCount >= 2, "boot notice marks every archived job announced");
+    assert.ok(store.listArchived().every((job) => Number.isFinite(job.announcedAt)),
+      "announcedAt must persist on archived records");
+    assert.strictEqual(store.markArchivedAnnounced(store.listArchived().map((job) => job.id)), 0,
+      "already-announced jobs are not re-marked");
+    assert.ok(store.ensureMigrated().archived.every((job) => Number.isFinite(job.announcedAt)),
+      "announcedAt must survive a re-migration pass");
+
+    const fresh = store.add({
+      id: "fresh-origin-job",
+      kind: "wakeup",
+      adapter: "telegram-fixture",
+      adapterType: "telegram",
+      channelId: "fixture-channel",
+      canonicalUserId: "telegram:fixture",
+      provider: "claude",
+      providerSettings: { model: "scheduled-model" },
+      project: "alpha",
+      projectDir: "/workspace/alpha",
+      sessionId: null,
+      originRunId: "fresh-origin-run",
+      sessionLineage: { originRunId: "fresh-origin-run", originSessionId: null },
+      prompt: "bind me after the fresh turn closes",
+      fireAt: 1_720_000_100_000,
+      occurrenceId: "fresh-origin-occurrence",
+    });
+    assert.strictEqual(fresh.sessionId, null);
+    assert.strictEqual(store.bindOriginRunSession("fresh-origin-run", "claude", "alpha", "fresh-native-session"), 1);
+    assert.strictEqual(store.get("fresh-origin-job").sessionId, "fresh-native-session");
+    assert.strictEqual(store.bindOriginRunSession("fresh-origin-run", "codex", "alpha", "wrong-provider"), 0);
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+
+  const interruptedRoot = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-jobs-interrupt-"));
+  try {
+    const configDir = path.join(interruptedRoot, "config");
+    fs.mkdirSync(configDir, { recursive: true });
+    const original = `${JSON.stringify([{
+      id: "legacy-interrupted",
+      kind: "wakeup",
+      adapter: "telegram-fixture",
+      adapterType: "telegram",
+      channelId: "fixture-channel",
+      canonicalUserId: "telegram:fixture",
+      project: "alpha",
+      sessionKey: "lastSessionId",
+      sessionId: "legacy-session",
+      prompt: "recover migration",
+      fireAt: 1_720_000_100_000,
+    }], null, 2)}\n`;
+    fs.writeFileSync(path.join(configDir, "jobs.json"), original);
+    const store = jobsApi.createJobsStore({
+      jobsFile: path.join(configDir, "jobs.json"),
+      configDir,
+      defaults: {},
+      now: () => 1_720_000_000_000,
+      occurrenceIdFactory: (job) => `occ-${job.id}`,
+    });
+    assert.throws(() => store.ensureMigrated({
+      faultInjector(point) {
+        if (point === "after-jobs-write") throw Object.assign(new Error("fixture interruption"), { code: "FIXTURE_INTERRUPTION" });
+      },
+    }), (error) => error.code === "FIXTURE_INTERRUPTION");
+    const pending = migrationApi.readMigrationJournal(configDir);
+    assert.ok(pending.pendingComponents.jobs);
+    assert.strictEqual(pending.components.jobs, null);
+    const recovered = store.ensureMigrated();
+    assert.strictEqual(recovered.jobs[0].provider, "claude");
+    assert.ok(migrationApi.readMigrationJournal(configDir).components.jobs);
+  } finally {
+    fs.rmSync(interruptedRoot, { recursive: true, force: true });
+  }
+
+  const malformedRoot = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-jobs-malformed-"));
+  try {
+    const configDir = path.join(malformedRoot, "config");
+    fs.mkdirSync(configDir, { recursive: true });
+    const malformedBytes = fs.readFileSync(path.join(fixturesRoot, "malformed-partial", "jobs.json"));
+    fs.writeFileSync(path.join(configDir, "jobs.json"), malformedBytes);
+    const store = jobsApi.createJobsStore({ jobsFile: path.join(configDir, "jobs.json"), configDir, now: () => 1_720_000_000_000 });
+    const migrated = store.ensureMigrated();
+    assert.strictEqual(migrated.jobs.length, 0);
+    assert.match(migrated.archived[0].archiveReason, /malformed/i);
+    const journal = migrationApi.readMigrationJournal(configDir);
+    const snapshotDir = path.join(migrationApi.migrationRoot(configDir), ...journal.snapshot.split("/"));
+    assert.deepStrictEqual(fs.readFileSync(path.join(snapshotDir, "originals", "jobs.json")), malformedBytes);
+  } finally {
+    fs.rmSync(malformedRoot, { recursive: true, force: true });
+  }
+}
+
+function memoryJobsStore(seed) {
+  const records = new Map(seed.map((job) => [job.id, structuredClone(job)]));
+  const archived = [];
+  const calls = { update: [], remove: [] };
+  return {
+    calls,
+    records,
+    archived,
+    ensureMigrated() { return { schemaVersion: 2, jobs: [...records.values()], archived }; },
+    listAll() { return [...records.values()].map((job) => structuredClone(job)); },
+    listArchived() { return archived.map((job) => structuredClone(job)); },
+    get(id) { const value = records.get(id); return value ? structuredClone(value) : null; },
+    add(job) { records.set(job.id, structuredClone(job)); return structuredClone(job); },
+    update(id, patch) {
+      calls.update.push({ id, patch: structuredClone(patch) });
+      const current = records.get(id);
+      if (!current) return null;
+      const next = { ...current, ...structuredClone(patch) };
+      records.set(id, next);
+      return structuredClone(next);
+    },
+    remove(id) {
+      calls.remove.push(id);
+      const value = records.get(id);
+      if (!value) return null;
+      records.delete(id);
+      return structuredClone(value);
+    },
+    archive(job) { archived.push(structuredClone(job)); records.delete(job.id); return job; },
+  };
+}
+
+function baseJob(overrides = {}) {
+  return {
+    id: "wake-1",
+    kind: "wakeup",
+    adapter: "telegram-fixture",
+    adapterType: "telegram",
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    userId: "fixture-user",
+    provider: "claude",
+    providerSettings: { model: "claude-scheduled", effort: "high" },
+    project: "alpha",
+    sessionId: "claude-before-compact",
+    sessionLineage: {
+      originRunId: "origin-run",
+      originSessionId: "claude-before-compact",
+    },
+    prompt: "scheduled prompt",
+    label: "fixture wakeup",
+    source: "agent",
+    fireAt: 1_720_000_000_000,
+    occurrenceId: "occ-wake-1",
+    status: "pending",
+    attemptCount: 0,
+    maxAttempts: 3,
+    disabled: false,
+    ...overrides,
+  };
+}
+
+function schedulerHarness(createSchedulerService, seed, options = {}) {
+  const jobsStore = options.jobsStore || memoryJobsStore(seed);
+  const scheduled = [];
+  const admissions = [];
+  const runCalls = [];
+  const sends = [];
+  const state = options.state || {
+    userId: "fixture-user",
+    currentSession: { name: "other-project", dir: "/workspace/other-project" },
+    settings: { backend: "codex" },
+    activeSessions: { alpha: { claude: "claude-after-compact" } },
+    completedCompactions: {
+      compacted: {
+        project: "alpha",
+        provider: "claude",
+        previousSessionId: "claude-before-compact",
+        newSessionId: "claude-after-compact",
+      },
+    },
+    runningProcess: null,
+    preparingRun: false,
+  };
+  const outcomes = options.outcomes || [];
+  let occurrenceSequence = 0;
+  const service = createSchedulerService({
+    jobsStore,
+    adapters: [{ id: "telegram-fixture", type: "telegram" }],
+    workspace: "/workspace",
+    now: options.now || (() => 1_720_000_000_500),
+    occurrenceIdFactory: () => `next-occ-${++occurrenceSequence}`,
+    setTimer(fn, delay) { scheduled.push({ fn, delay }); return { fn, delay }; },
+    clearTimer() {},
+    runInChat: async (_ctx, fn) => fn(),
+    getUserState: () => state,
+    send: async (text) => { sends.push(text); if (options.onSend) await options.onSend(state); return { ok: true }; },
+    admitRunContext(prompt, cwd, _replyTo, opts) {
+      const context = Object.freeze({
+        runId: `scheduled-${admissions.length + 1}`,
+        provider: opts.provider,
+        project: Object.freeze({ ...opts.project }),
+        sessionId: opts.fresh ? null : (opts.resumeSessionId || null),
+        providerSettings: Object.freeze({ ...(opts.providerSettings || {}) }),
+        occurrenceId: opts.occurrenceId || null,
+        scheduledJobId: opts.scheduledJobId || null,
+        userPrompt: prompt,
+        cwd,
+        requiredDelivery: true,
+      });
+      admissions.push({ context, opts: structuredClone(opts) });
+      return context;
+    },
+    async runAgent(prompt, cwd, _replyTo, opts) {
+      runCalls.push({ prompt, cwd, opts });
+      const next = outcomes.shift();
+      return next && typeof next.then === "function" ? next : next;
+    },
+    providerStatus: options.providerStatus || (() => ({ availability: { state: "available" }, auth: { state: "authenticated" } })),
+    fallbackProviders: options.fallbackProviders || [],
+    retryDelayMs: 1000,
+    busyDelayMs: 250,
+    missedGraceMs: 60 * 60 * 1000,
+  });
+  return { service, jobsStore, scheduled, admissions, runCalls, sends, state };
+}
+
+async function immutableTerminalProbe(createSchedulerService) {
+  const terminal = deferred();
+  const h = schedulerHarness(createSchedulerService, [baseJob()], {
+    outcomes: [terminal.promise],
+    onSend(state) {
+      state.settings.backend = "codex";
+      state.currentSession = { name: "switched", dir: "/workspace/switched" };
+    },
+  });
+  const firing = h.service.fireJob("wake-1");
+  await nextTurn();
+  assert.strictEqual(h.admissions.length, 1);
+  assert.strictEqual(h.admissions[0].opts.provider, "claude");
+  assert.strictEqual(h.admissions[0].opts.project.name, "alpha");
+  assert.strictEqual(h.admissions[0].opts.resumeSessionId, "claude-after-compact", "compaction lineage should rebase the saved session");
+  assert.deepStrictEqual(h.admissions[0].opts.providerSettings, { model: "claude-scheduled", effort: "high" });
+  assert.strictEqual(h.admissions[0].opts.occurrenceId, "occ-wake-1");
+  assert.strictEqual(h.admissions[0].opts.scheduledJobId, "wake-1");
+  assert.strictEqual(h.admissions[0].opts.attachSession, true);
+  assert.strictEqual(h.admissions[0].opts.requiredDelivery, true);
+  assert.strictEqual(h.jobsStore.calls.remove.length, 0, "one-shot must survive until terminal settlement");
+  terminal.resolve({
+    ok: true,
+    status: "succeeded",
+    persistence: { transcript: { ok: true }, usage: { ok: true }, session: { ok: true } },
+    delivery: { ok: true },
+  });
+  const result = await firing;
+  assert.strictEqual(result.ok, true);
+  assert.deepStrictEqual(h.jobsStore.calls.remove, ["wake-1"]);
+}
+
+async function duplicateFireProbe(createSchedulerService) {
+  const terminal = deferred();
+  const h = schedulerHarness(createSchedulerService, [baseJob({ id: "single-flight" })], {
+    outcomes: [terminal.promise],
+  });
+  const first = h.service.fireJob("single-flight");
+  await nextTurn();
+  const duplicate = await h.service.fireJob("single-flight");
+  assert.deepStrictEqual(
+    { status: duplicate.status, skipped: duplicate.skipped, inFlight: duplicate.inFlight },
+    { status: "running", skipped: true, inFlight: true },
+    "a persisted in-flight occurrence cannot be admitted twice",
+  );
+  assert.strictEqual(h.admissions.length, 1);
+  assert.strictEqual(h.runCalls.length, 1);
+  terminal.resolve({
+    ok: true,
+    status: "succeeded",
+    persistence: { transcript: { ok: true }, usage: { ok: true }, session: { ok: true } },
+    delivery: { ok: true },
+  });
+  assert.strictEqual((await first).ok, true);
+}
+
+async function failureAndRetryProbe(createSchedulerService) {
+  const failureResults = [
+    { ok: false, status: "failed", exitCode: 23, error: { code: "PROVIDER_EXIT_NONZERO", message: "code 23" }, delivery: { ok: true } },
+    { ok: true, status: "succeeded", persistence: { transcript: { ok: false } }, delivery: { ok: true } },
+    { ok: true, status: "succeeded", persistence: { transcript: { ok: true } }, delivery: { ok: false } },
+  ];
+  for (const [index, outcome] of failureResults.entries()) {
+    const id = `failed-${index}`;
+    const h = schedulerHarness(createSchedulerService, [baseJob({ id, occurrenceId: `occ-${id}` })], { outcomes: [outcome] });
+    const fired = await h.service.fireJob(id);
+    assert.strictEqual(fired.ok, false);
+    assert.ok(h.jobsStore.get(id), `${id}: failed one-shot remains durable`);
+    assert.strictEqual(h.jobsStore.calls.remove.length, 0);
+    assert.strictEqual(h.jobsStore.get(id).status, "failed");
+    assert.strictEqual(h.jobsStore.get(id).attemptCount, 1);
+    assert.strictEqual(h.jobsStore.get(id).occurrenceId, `occ-${id}`, "retry retains stable occurrence id");
+    assert.strictEqual(h.scheduled.length, 1, "retry is durably re-armed");
+  }
+
+  const exhausted = schedulerHarness(createSchedulerService, [baseJob({ id: "exhausted", occurrenceId: "occ-exhausted", maxAttempts: 2 })], {
+    outcomes: [
+      { ok: false, status: "failed", error: { message: "first" }, delivery: { ok: true } },
+      { ok: false, status: "failed", error: { message: "second" }, delivery: { ok: true } },
+    ],
+  });
+  await exhausted.service.fireJob("exhausted");
+  await exhausted.service.fireJob("exhausted");
+  const dead = exhausted.jobsStore.get("exhausted");
+  assert.strictEqual(dead.status, "dead-letter");
+  assert.strictEqual(dead.disabled, true);
+  assert.strictEqual(dead.attemptCount, 2);
+  assert.strictEqual(exhausted.jobsStore.calls.remove.length, 0);
+
+  const persistenceStore = memoryJobsStore([baseJob({ id: "success-persist-fails", occurrenceId: "occ-persist-fails" })]);
+  const normalUpdate = persistenceStore.update.bind(persistenceStore);
+  persistenceStore.update = (id, patch) => {
+    if (patch.status === "succeeded") throw new Error("jobs success marker failed");
+    return normalUpdate(id, patch);
+  };
+  const persistence = schedulerHarness(createSchedulerService, [], {
+    jobsStore: persistenceStore,
+    outcomes: [{
+      ok: true,
+      status: "succeeded",
+      persistence: { transcript: { ok: true }, usage: { ok: true }, session: { ok: true } },
+      delivery: { ok: true },
+    }],
+  });
+  const notLost = await persistence.service.fireJob("success-persist-fails");
+  assert.strictEqual(notLost.ok, false);
+  assert.strictEqual(persistenceStore.calls.remove.length, 0, "job persistence failure cannot delete a successful one-shot");
+  assert.ok(persistenceStore.get("success-persist-fails"));
+}
+
+async function detachedHistoricalBranchProbe(createSchedulerService) {
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "other", dir: "/workspace/other" },
+    settings: { backend: "codex" },
+    activeSessions: { alpha: { claude: "unrelated-live-session" } },
+    completedCompactions: {},
+    runningProcess: null,
+    preparingRun: false,
+  };
+  const h = schedulerHarness(createSchedulerService, [baseJob({ id: "historical", occurrenceId: "occ-historical" })], {
+    state,
+    outcomes: [{
+      ok: true,
+      status: "succeeded",
+      persistence: { transcript: { ok: true }, usage: { ok: true }, session: { ok: true } },
+      delivery: { ok: true },
+    }],
+  });
+  await h.service.fireJob("historical");
+  assert.strictEqual(h.admissions[0].opts.resumeSessionId, "claude-before-compact");
+  assert.strictEqual(h.admissions[0].opts.attachSession, false, "historical scheduled work must not replace an unrelated live branch");
+}
+
+async function busyRestartAndMissedProbe(createSchedulerService) {
+  const busyState = {
+    userId: "fixture-user",
+    currentSession: { name: "alpha", dir: "/workspace/alpha" },
+    settings: { backend: "claude" },
+    activeSessions: { alpha: { claude: "session" } },
+    completedCompactions: {},
+    runningProcess: { pid: 1 },
+    preparingRun: false,
+  };
+  const busy = schedulerHarness(createSchedulerService, [baseJob({ id: "busy", sessionId: "session" })], { state: busyState });
+  const deferredBusy = await busy.service.fireJob("busy");
+  assert.strictEqual(deferredBusy.deferred, true);
+  assert.strictEqual(busy.runCalls.length, 0);
+  assert.strictEqual(busy.jobsStore.get("busy").status, "deferred");
+  assert.strictEqual(busy.jobsStore.get("busy").attemptCount, 0, "busy deferral is not a provider attempt");
+  assert.strictEqual(busy.scheduled.length, 1);
+
+  const restartNow = 1_720_000_000_500;
+  const restart = schedulerHarness(createSchedulerService, [
+    baseJob({ id: "retry-after-restart", status: "failed", attemptCount: 1, nextAttemptAt: restartNow + 5000 }),
+    baseJob({ id: "missed-once", fireAt: restartNow - 500, status: "pending" }),
+  ], { now: () => restartNow });
+  restart.service.init();
+  const retryTimers = restart.scheduled.filter((entry) => entry.delay === 5000);
+  const missedTimers = restart.scheduled.filter((entry) => entry.delay === 0);
+  assert.strictEqual(retryTimers.length, 1, "restart re-arms a pending retry once");
+  assert.strictEqual(missedTimers.length, 1, "a missed wakeup gets exactly one startup attempt");
+}
+
+async function unavailableAndFallbackProbe(createSchedulerService) {
+  const noFallback = schedulerHarness(createSchedulerService, [baseJob({ id: "unavailable" })], {
+    providerStatus: () => ({ availability: { state: "missing" }, auth: { state: "not_checked" } }),
+  });
+  const unavailable = await noFallback.service.fireJob("unavailable");
+  assert.strictEqual(unavailable.ok, false);
+  assert.strictEqual(noFallback.runCalls.length, 0);
+  assert.strictEqual(noFallback.jobsStore.get("unavailable").status, "failed");
+
+  const fallback = schedulerHarness(createSchedulerService, [baseJob({ id: "fallback" })], {
+    fallbackProviders: ["codex"],
+    providerStatus(provider) {
+      return provider === "claude"
+        ? { availability: { state: "missing" }, auth: { state: "not_checked" } }
+        : { availability: { state: "available" }, auth: { state: "authenticated" } };
+    },
+    outcomes: [{
+      ok: true,
+      status: "succeeded",
+      persistence: { transcript: { ok: true }, usage: { ok: true }, session: { ok: true } },
+      delivery: { ok: true },
+    }],
+  });
+  const succeeded = await fallback.service.fireJob("fallback");
+  assert.strictEqual(succeeded.ok, true);
+  assert.strictEqual(fallback.admissions[0].opts.provider, "codex");
+  assert.strictEqual(fallback.admissions[0].opts.fresh, true);
+  assert.ok(!fallback.admissions[0].opts.resumeSessionId, "fallback cannot receive another provider's native session id");
+  assert.match(fallback.runCalls[0].prompt, /archived provider-neutral brief/i);
+  assert.match(fallback.runCalls[0].prompt, /claude/i);
+}
+
+async function cronOccurrenceProbe(createSchedulerService) {
+  const h = schedulerHarness(createSchedulerService, [baseJob({
+    id: "cron-1",
+    kind: "cron",
+    schedule: "0 9 * * 1-5",
+    fireAt: undefined,
+    occurrenceId: "cron-occurrence",
+  })], {
+    outcomes: [{
+      ok: true,
+      status: "succeeded",
+      persistence: { transcript: { ok: true }, usage: { ok: true }, session: { ok: true } },
+      delivery: { ok: true },
+    }],
+  });
+  await h.service.fireJob("cron-1");
+  const cron = h.jobsStore.get("cron-1");
+  assert.ok(cron);
+  assert.strictEqual(cron.status, "pending");
+  assert.strictEqual(cron.attemptCount, 0);
+  assert.strictEqual(cron.occurrenceId, "next-occ-1", "next cron fire gets a new stable occurrence id");
+}
+
+function creationEnrichmentProbe(createSchedulerService) {
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "alpha", dir: "/workspace/alpha" },
+    settings: { backend: "codex" },
+    activeSessions: { alpha: { codex: "thread-alpha" } },
+    providerSettings: { codex: { model: "gpt-scheduled", effort: "high" } },
+    activeRunContext: { runId: "origin-run" },
+  };
+  const service = createSchedulerService({
+    jobsStore: memoryJobsStore([]),
+    currentState: () => state,
+    occurrenceIdFactory: () => "origin-occurrence",
+    setTimer: () => ({}),
+    clearTimer: () => {},
+  });
+  const enriched = service.enrichJobSpec({
+    kind: "cron",
+    adapter: "telegram-fixture",
+    adapterType: "telegram",
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    project: "alpha",
+    prompt: "direct cron",
+    schedule: "0 9 * * 1-5",
+  });
+  assert.strictEqual(enriched.provider, "codex");
+  assert.strictEqual(enriched.project, "alpha");
+  assert.strictEqual(enriched.projectDir, "/workspace/alpha");
+  assert.strictEqual(enriched.sessionId, "thread-alpha");
+  assert.deepStrictEqual(enriched.providerSettings, {
+    model: "gpt-scheduled", effort: "high", budget: null, permissionMode: null, worktree: false,
+  });
+  assert.strictEqual(enriched.originRunId, "origin-run");
+  assert.strictEqual(enriched.occurrenceId, "origin-occurrence");
+}
+
+function loopbackMetadataProbe(runner, loopbackClient) {
+  const invocation = runner.decorateForegroundInvocation({
+    binary: "/fixture/provider",
+    args: [],
+    env: {},
+    stdin: null,
+    parserState: {},
+  }, {
+    runId: "run-metadata",
+    provider: "codex",
+    project: { name: "alpha", dir: "/workspace/alpha" },
+    sessionId: "thread-alpha",
+    admittedSessionId: "thread-alpha",
+    previousSessionId: "thread-before",
+    canonicalUserId: "fixture-user",
+    channelId: "fixture-channel",
+    origin: { adapterId: "telegram-fixture", userId: "fixture-user" },
+    purpose: "foreground",
+  }, { transcriptPaths: {} });
+  assert.strictEqual(invocation.env.OC_PROVIDER, "codex");
+  assert.strictEqual(invocation.env.OC_RUN_ID, "run-metadata");
+  assert.strictEqual(invocation.env.OC_PROJECT, "alpha");
+  assert.strictEqual(invocation.env.OC_PROJECT_DIR, "/workspace/alpha");
+  assert.strictEqual(invocation.env.OC_SESSION_ID, "thread-alpha");
+  assert.strictEqual(invocation.env.OC_PREVIOUS_SESSION_ID, "thread-before");
+
+  const previous = { ...process.env };
+  try {
+    Object.assign(process.env, invocation.env);
+    const context = loopbackClient.context();
+    assert.strictEqual(context.provider, "codex");
+    assert.strictEqual(context.project, "alpha");
+    assert.strictEqual(context.projectDir, "/workspace/alpha");
+    assert.strictEqual(context.runId, "run-metadata");
+    assert.strictEqual(context.sessionId, "thread-alpha");
+    assert.strictEqual(context.previousSessionId, "thread-before");
+  } finally {
+    for (const key of Object.keys(process.env)) {
+      if (!Object.prototype.hasOwnProperty.call(previous, key)) delete process.env[key];
+    }
+    Object.assign(process.env, previous);
+  }
+}
+
+function staticSchedulingProbe() {
+  const files = [
+    "core/jobs.js",
+    "core/scheduler.js",
+    "core/loopback.js",
+    "bin/loopback-client.js",
+    "bin/schedule.js",
+    "bin/cli.js",
+  ];
+  const source = Object.fromEntries(files.map((file) => [file, fs.readFileSync(path.join(root, file), "utf8")]));
+  for (const file of ["core/jobs.js", "core/scheduler.js", "core/loopback.js", "bin/loopback-client.js", "bin/schedule.js"]) {
+    if (file === "core/jobs.js") continue;
+    assert.ok(!/\bsessionKey\b/.test(source[file]), `${file} must not use the removed sessionKey scheduling field`);
+  }
+  assert.match(source["bin/cli.js"], /selected provider session/i);
+}
+
+async function main() {
+  const jobsApi = require("./core/jobs");
+  const migrationApi = require("./core/migration-backup");
+  const schedulerApi = require("./core/scheduler");
+  assert.strictEqual(typeof jobsApi.migrateJobsDocument, "function");
+  assert.strictEqual(typeof jobsApi.createJobsStore, "function");
+  assert.strictEqual(typeof schedulerApi.createSchedulerService, "function");
+
+  migrationProbe(jobsApi);
+  migrationIntegrationProbe(jobsApi, migrationApi);
+  await immutableTerminalProbe(schedulerApi.createSchedulerService);
+  await duplicateFireProbe(schedulerApi.createSchedulerService);
+  await failureAndRetryProbe(schedulerApi.createSchedulerService);
+  await detachedHistoricalBranchProbe(schedulerApi.createSchedulerService);
+  await busyRestartAndMissedProbe(schedulerApi.createSchedulerService);
+  await unavailableAndFallbackProbe(schedulerApi.createSchedulerService);
+  await cronOccurrenceProbe(schedulerApi.createSchedulerService);
+  creationEnrichmentProbe(schedulerApi.createSchedulerService);
+  loopbackMetadataProbe(require("./core/runner"), require("./bin/loopback-client"));
+  staticSchedulingProbe();
+  console.log("provider scheduler OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});