@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-provider-gateway.js

@@ -0,0 +1,508 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+function installStub(relativePath, exports) {
+  const filename = require.resolve(relativePath);
+  require.cache[filename] = { id: filename, filename, loaded: true, exports };
+}
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((res) => { resolve = res; });
+  return { promise, resolve };
+}
+
+function nextTurn() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+async function routerProbe() {
+  const projectA = path.join(process.env.WORKSPACE, "project-a");
+  const projectB = path.join(process.env.WORKSPACE, "project-b");
+  fs.mkdirSync(projectA, { recursive: true });
+  fs.mkdirSync(projectB, { recursive: true });
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "project-a", dir: projectA },
+    settings: { backend: "claude", model: "claude-fixture" },
+    activeSessions: { "project-a": { claude: "claude-session", codex: "codex-session" } },
+    providerSettings: {
+      claude: { model: "claude-fixture" },
+      codex: { model: "codex-fixture" },
+    },
+    messageQueue: [],
+    pendingCodexAuthProcess: null,
+    pendingClaudeAuthProcess: null,
+    pendingVaultUnlock: false,
+    onboardingStep: null,
+    lastInputWasVoice: false,
+  };
+  const admissions = [];
+  const runs = [];
+  const sends = [];
+  let runSequence = 0;
+
+  installStub("./core/state", {
+    currentState: () => state,
+    autoLinkOwnerChannel: () => null,
+  });
+  installStub("./core/runner", {
+    admitRunContext(prompt, cwd, replyToMsgId, opts = {}) {
+      const snapshot = Object.freeze({
+        runId: `gateway-run-${++runSequence}`,
+        provider: state.settings.backend,
+        providerSettings: Object.freeze({ ...state.providerSettings[state.settings.backend] }),
+        project: Object.freeze({ ...state.currentSession }),
+        sessionId: state.activeSessions[state.currentSession.name]?.[state.settings.backend] || null,
+        cwd,
+        replyToMsgId,
+        userPrompt: prompt,
+        origin: Object.freeze({ transport: opts.transport || null, channelId: "fixture-channel" }),
+      });
+      admissions.push(snapshot);
+      return snapshot;
+    },
+    async runAgent(prompt, cwd, replyToMsgId, opts = {}) {
+      runs.push({ prompt, cwd, replyToMsgId, opts });
+      return {
+        ok: true,
+        status: "succeeded",
+        runId: opts.runContext?.runId,
+        provider: opts.runContext?.provider,
+        project: opts.runContext?.project,
+        text: "fixture response",
+        delivery: { ok: true },
+      };
+    },
+  });
+  installStub("./core/media", { transcribeAudio: (file) => `transcript:${path.basename(file)}` });
+  installStub("./core/io", {
+    send: async (text, opts) => { sends.push({ text, opts }); return { ok: true, messageId: String(sends.length), editable: true }; },
+    deleteMessage: async () => true,
+  });
+  installStub("./core/access", { isChatAuthorized: () => true });
+  installStub("./core/onboarding", { isOnboarded: () => true, handleOnboarding: async () => {} });
+  installStub("./core/commands", { dispatch: async () => ({ matched: false }) });
+  installStub("./core/actions", { handleAction: async () => {} });
+  installStub("./core/handlers", {});
+  installStub("./core/intro-flow", { handleInbound: async () => {} });
+  installStub("./core/vault-store", {
+    vault: { exists: () => false, isUnlocked: () => false, unlock: () => false, list: () => ({}), get: () => null },
+  });
+  installStub("./core/auth-flow", {
+    looksLikeOpenAIKey: () => false,
+    looksLikeClaudeToken: () => false,
+    looksLikeClaudeAuthReply: () => false,
+    saveClaudeOAuthToken: () => {},
+    saveCodexApiKeyWithCli: async () => ({ ok: false, output: "" }),
+    clearPendingClaudeAuth: () => {},
+    clearPendingCodexAuth: () => {},
+    sendClaudeAuthStatusSummary: async () => {},
+    sendCodexAuthStatusSummary: async () => {},
+  });
+  installStub("./core/channel-wizard", {
+    tryCaptureOwner: async () => false,
+    isAwaiting: () => false,
+    handleText: async () => false,
+    handleAction: async () => false,
+    cancel: async () => {},
+  });
+
+  const router = require("./core/router");
+  let messageId = 0;
+  function adapter(type = "telegram", download) {
+    return {
+      id: `${type}-fixture`,
+      type,
+      typing: async () => {},
+      downloadMedia: download || (async (media) => path.join(process.env.OPEN_CLAUDIA_CONFIG_DIR, media.fileName || `${media.type || "media"}-${messageId}`)),
+    };
+  }
+  function envelope(type, overrides = {}) {
+    messageId += 1;
+    const channelAdapter = overrides.adapter || adapter(type === "voice" ? "voice" : "telegram");
+    return {
+      type,
+      adapter: channelAdapter,
+      channelId: "fixture-channel",
+      canonicalUserId: "fixture-user",
+      userId: "fixture-user",
+      messageId: `message-${messageId}`,
+      raw: null,
+      ...overrides,
+      adapter: channelAdapter,
+    };
+  }
+  function resetRouting() {
+    state.currentSession = { name: "project-a", dir: projectA };
+    state.settings = { backend: "claude", model: "claude-fixture" };
+    state.activeSessions["project-a"].claude = "claude-session";
+  }
+
+  // Voice admission precedes download/transcription. A switch during media
+  // preparation cannot retarget the admitted provider or project.
+  {
+    resetRouting();
+    const gate = deferred();
+    const voice = envelope("voice", {
+      adapter: adapter("voice", async () => { await gate.promise; return path.join(process.env.OPEN_CLAUDIA_CONFIG_DIR, "voice.ogg"); }),
+      media: [{ type: "voice", size: 10 }],
+    });
+    const pending = router.onMessage(voice);
+    await nextTurn();
+    const admitted = admissions.at(-1);
+    assert.strictEqual(admitted.provider, "claude");
+    assert.strictEqual(admitted.project.name, "project-a");
+    state.currentSession = { name: "project-b", dir: projectB };
+    state.settings = { backend: "codex", model: "codex-fixture" };
+    gate.resolve();
+    await pending;
+    const run = runs.at(-1);
+    assert.strictEqual(run.opts.runContext, admitted);
+    assert.strictEqual(run.opts.lastInputWasVoice, true);
+    assert.strictEqual(run.opts.voiceStream, true);
+    assert.match(run.prompt, /transcript:voice\.ogg/);
+  }
+
+  {
+    resetRouting();
+    await router.onMessage(envelope("audio", { media: [{ type: "audio" }] }));
+    assert.strictEqual(runs.at(-1).opts.runContext, admissions.at(-1));
+    assert.match(runs.at(-1).prompt, /^transcript:/);
+  }
+
+  {
+    resetRouting();
+    await router.onMessage(envelope("photo", {
+      caption: "compare these",
+      media: [{ type: "photo", fileName: "one.png" }, { type: "photo", fileName: "two.png" }],
+    }));
+    const run = runs.at(-1);
+    assert.strictEqual(run.opts.runContext, admissions.at(-1));
+    assert.deepStrictEqual(run.opts.imagePaths.map((imagePath) => path.basename(imagePath)), ["one.png", "two.png"]);
+    assert.match(run.prompt, /compare these/);
+  }
+
+  {
+    resetRouting();
+    await router.onMessage(envelope("document", {
+      caption: "inspect",
+      media: [{ type: "document", fileName: "screen.png", mimeType: "image/png", size: 12 }],
+    }));
+    const run = runs.at(-1);
+    assert.deepStrictEqual(run.opts.imagePaths.map((imagePath) => path.basename(imagePath)), ["screen.png"]);
+    assert.strictEqual(run.opts.runContext, admissions.at(-1));
+  }
+
+  {
+    resetRouting();
+    await router.onMessage(envelope("document", {
+      media: [{ type: "document", fileName: "notes.pdf", mimeType: "application/pdf", size: 12 }],
+    }));
+    const run = runs.at(-1);
+    assert.deepStrictEqual(run.opts.imagePaths, []);
+    assert.strictEqual(run.opts.attachments[0].mimeType, "application/pdf");
+  }
+
+  {
+    resetRouting();
+    const gate = deferred();
+    const text = envelope("text", {
+      text: "answer this",
+      reply: { document: { file_name: "quoted.txt", file_id: "file-id", mime_type: "text/plain" } },
+      adapter: adapter("telegram", async () => { await gate.promise; return path.join(process.env.OPEN_CLAUDIA_CONFIG_DIR, "quoted.txt"); }),
+    });
+    const pending = router.onMessage(text);
+    await nextTurn();
+    const admitted = admissions.at(-1);
+    state.settings = { backend: "codex", model: "codex-fixture" };
+    state.currentSession = { name: "project-b", dir: projectB };
+    gate.resolve();
+    await pending;
+    assert.strictEqual(runs.at(-1).opts.runContext, admitted);
+    assert.match(runs.at(-1).prompt, /quoted\.txt/);
+  }
+
+  {
+    resetRouting();
+    await router.onMessage(envelope("text", { text: "plain text" }));
+    assert.strictEqual(runs.at(-1).opts.runContext, admissions.at(-1));
+    assert.strictEqual(runs.at(-1).prompt, "plain text");
+  }
+
+  assert.ok(sends.length > 0, "media acknowledgement delivery remains active");
+  console.log("provider gateway router OK");
+}
+
+async function schedulerProbe() {
+  const projectA = path.join(process.env.WORKSPACE, "project-a");
+  const projectB = path.join(process.env.WORKSPACE, "project-b");
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "project-a", dir: projectA },
+    settings: { backend: "claude", model: "claude-fixture" },
+    activeSessions: { "project-a": { claude: "claude-session" } },
+    providerSettings: { claude: { model: "claude-fixture" }, codex: { model: "codex-fixture" } },
+    runningProcess: null,
+    preparingRun: false,
+  };
+  fs.mkdirSync(state.currentSession.dir, { recursive: true });
+  const records = new Map();
+  const removed = [];
+  const admissions = [];
+  const outcomes = [];
+  let notificationHook = null;
+
+  installStub("./core/jobs", {
+    ensureMigrated: () => ({ schemaVersion: 2, jobs: [], archived: [] }),
+    get(id) { return records.get(id) || null; },
+    update(id, patch) {
+      const next = { ...(records.get(id) || {}), ...patch };
+      records.set(id, next);
+      return next;
+    },
+    remove(id) { removed.push(id); return true; },
+    listAll: () => [],
+    add: (job) => job,
+    nextId: () => "job-next",
+  });
+  installStub("./core/providers", {
+    providerStatus: () => ({
+      availability: { state: "available" },
+      compatibility: { state: "compatible" },
+      auth: { state: "authenticated" },
+    }),
+  });
+  installStub("./core/state", {
+    getUserState: () => state,
+    getProviderSession: (_state, provider, project) => (
+      state.activeSessions?.[project]?.[provider] || null
+    ),
+    userStates: new Map(),
+  });
+  installStub("./core/identity", {
+    canonicalForTelegram: () => "fixture-user",
+    canonicalForChannel: () => "fixture-user",
+  });
+  installStub("./core/io", {
+    send: async () => {
+      const hook = notificationHook;
+      notificationHook = null;
+      if (hook) await hook();
+      return { ok: true, messageId: "sent", editable: true };
+    },
+  });
+  installStub("./core/runner", {
+    admitRunContext(prompt, cwd, replyTo, opts = {}) {
+      const context = Object.freeze({
+        runId: `scheduled-${admissions.length + 1}`,
+        provider: opts.provider || state.settings.backend,
+        project: Object.freeze({ ...state.currentSession }),
+        providerSettings: Object.freeze({ ...state.providerSettings[opts.provider || state.settings.backend] }),
+        sessionId: opts.resumeSessionId || state.activeSessions[state.currentSession.name]?.[opts.provider || state.settings.backend] || null,
+        userPrompt: prompt,
+        cwd,
+      });
+      admissions.push(context);
+      return context;
+    },
+    async runAgent(_prompt, _cwd, _reply, opts) {
+      assert.strictEqual(opts.runContext, admissions.at(-1));
+      return outcomes.shift();
+    },
+  });
+
+  const scheduler = require("./core/scheduler");
+  const channelAdapter = { id: "telegram-fixture", type: "telegram", send: async () => "sent" };
+  scheduler.setAdapters([channelAdapter]);
+  const base = {
+    kind: "wakeup",
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    userId: "fixture-user",
+    adapter: "telegram-fixture",
+    adapterType: "telegram",
+    provider: "claude",
+    providerSettings: { model: "claude-fixture" },
+    project: "project-a",
+    projectDir: state.currentSession.dir,
+    prompt: "scheduled prompt",
+    label: "fixture wakeup",
+    sessionId: "scheduled-session",
+  };
+
+  records.set("job-failed", { ...base, id: "job-failed", occurrenceId: "occ-failed", status: "pending", attemptCount: 0, maxAttempts: 3 });
+  outcomes.push({ ok: false, status: "failed", diagnostic: "fixture failed", error: { message: "fixture failed" }, delivery: { ok: true } });
+  notificationHook = async () => {
+    state.currentSession = { name: "project-b", dir: projectB };
+    state.settings = { backend: "codex", model: "codex-fixture" };
+    await nextTurn();
+  };
+  await scheduler.fireJob({ ...base, id: "job-failed" });
+  assert.strictEqual(records.get("job-failed").lastFireOk, false);
+  assert.ok(!removed.includes("job-failed"), "failed one-shot remains retryable");
+  assert.strictEqual(admissions[0].provider, "claude");
+  assert.strictEqual(admissions[0].project.name, "project-a");
+
+  state.currentSession = { name: "project-a", dir: projectA };
+  state.settings = { backend: "claude", model: "claude-fixture" };
+  records.set("job-success", { ...base, id: "job-success", occurrenceId: "occ-success", status: "pending", attemptCount: 0, maxAttempts: 3 });
+  outcomes.push({ ok: true, status: "succeeded", delivery: { ok: true } });
+  await scheduler.fireJob({ ...base, id: "job-success" });
+  assert.strictEqual(records.get("job-success").lastFireOk, true);
+  assert.ok(removed.includes("job-success"), "successful terminal one-shot is removed");
+  assert.strictEqual(admissions.length, 2);
+  scheduler.stopAll();
+  console.log("provider gateway scheduler OK");
+}
+
+function queueProbe() {
+  const projectA = path.join(process.env.WORKSPACE, "project-a");
+  const projectB = path.join(process.env.WORKSPACE, "project-b");
+  fs.mkdirSync(projectA, { recursive: true });
+  fs.mkdirSync(projectB, { recursive: true });
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "project-a", dir: projectA },
+    settings: { backend: "claude", model: "claude-fixture", effort: "high" },
+    activeSessions: { "project-a": { claude: "claude-queued-session", codex: "codex-live-session" } },
+    providerSettings: {
+      claude: { model: "claude-fixture", effort: "high" },
+      codex: { model: "codex-fixture", effort: "low" },
+    },
+    messageQueue: [],
+    preparingRun: true,
+    runningProcess: null,
+    isCompacting: false,
+    lastInputWasVoice: false,
+  };
+  const store = Object.freeze({
+    adapter: { id: "telegram-fixture", type: "telegram" },
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    userId: "fixture-user",
+    transport: "telegram",
+  });
+
+  installStub("./core/state", {
+    currentState: () => state,
+    saveState: () => {},
+    recordSession: () => {},
+    userOwnsProviderSession: () => false,
+    resetSessionUsage: () => {},
+    acquireRunLock: () => false,
+  });
+  installStub("./core/context", {
+    chatContext: { getStore: () => store, run: (_store, fn) => fn() },
+    currentChannelId: () => store.channelId,
+    currentAdapter: () => store.adapter,
+    currentUserId: () => store.userId,
+  });
+  installStub("./core/io", {
+    send: async () => ({ ok: true, messageId: "queued", editable: true }),
+    editMessage: async () => ({ ok: true }),
+    sendVoice: async () => ({ ok: true }),
+    sendVoiceEnd: async () => ({ ok: true }),
+    splitMessage: (text) => [text],
+  });
+  installStub("./core/tool-guard", { ensureHookSettings: () => ({ enabled: true }) });
+
+  const { runAgent } = require("./core/runner");
+  const pending = runAgent("queued prompt", projectA, "message-queued", { runId: "queued-run" });
+  assert.strictEqual(typeof pending.then, "function");
+  assert.strictEqual(state.messageQueue.length, 1);
+  const queued = state.messageQueue[0];
+  assert.ok(Object.isFrozen(queued.runContext));
+  assert.ok(Object.isFrozen(queued.runContext.project));
+  assert.ok(Object.isFrozen(queued.runContext.providerSettings));
+
+  state.currentSession = { name: "project-b", dir: projectB };
+  state.settings = { backend: "codex", model: "codex-fixture", effort: "low" };
+  state.activeSessions["project-a"].claude = "claude-changed-session";
+  state.activeSessions["project-a"].codex = "codex-changed-session";
+
+  assert.strictEqual(queued.runContext.runId, "queued-run");
+  assert.strictEqual(queued.runContext.provider, "claude");
+  assert.strictEqual(queued.runContext.project.name, "project-a");
+  assert.strictEqual(queued.runContext.project.dir, projectA);
+  assert.strictEqual(queued.runContext.providerSettings.model, "claude-fixture");
+  assert.strictEqual(queued.runContext.sessionId, "claude-queued-session");
+  console.log("provider gateway immutable queue OK");
+}
+
+async function childMain(mode) {
+  if (mode === "--router-probe") return routerProbe();
+  if (mode === "--scheduler-probe") return schedulerProbe();
+  if (mode === "--queue-probe") return queueProbe();
+  throw new Error(`unknown probe: ${mode}`);
+}
+
+function staticChecks() {
+  const files = [
+    "core/router.js",
+    "core/handlers.js",
+    "core/actions.js",
+    "core/scheduler.js",
+    "core/runner.js",
+    "bin/cli.js",
+  ];
+  const source = Object.fromEntries(files.map((file) => [file, fs.readFileSync(path.join(__dirname, file), "utf8")]));
+  for (const [file, text] of Object.entries(source)) {
+    assert.ok(!/\brunClaude\s*\(/.test(text), `${file} must have no active runClaude call`);
+  }
+  for (const file of ["core/router.js", "core/handlers.js", "core/actions.js", "core/scheduler.js"]) {
+    assert.match(source[file], /\brunAgent\b/, `${file} routes through runAgent`);
+  }
+  assert.match(source["core/router.js"], /\badmitRunContext\b/, "media/text ingress captures before preparation awaits");
+  assert.match(source["core/scheduler.js"], /result\.ok/, "scheduler consumes terminal RunResult success");
+  assert.match(source["core/runner.js"], /messageQueue\.push\(\{ runContext,/, "queued work stores its immutable run context");
+  assert.match(source["core/runner.js"], /executeAdmittedRun\(item\.runContext,/, "queue drain executes the admitted context");
+  assert.match(source["bin/cli.js"], /Open Claudia agent task/);
+  assert.ok(!source["bin/cli.js"].includes("inside a running Claude task"));
+}
+
+if (process.argv[2]) {
+  childMain(process.argv[2]).catch((error) => {
+    console.error(error.stack || error.message);
+    process.exit(1);
+  });
+} else {
+  staticChecks();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-provider-gateway-"));
+  const configDir = path.join(root, "config");
+  const workspace = path.join(root, "workspace");
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.mkdirSync(workspace, { recursive: true });
+  try {
+    for (const mode of ["--router-probe", "--scheduler-probe", "--queue-probe"]) {
+      const child = spawnSync(process.execPath, [__filename, mode], {
+        cwd: __dirname,
+        env: {
+          HOME: root,
+          PATH: process.env.PATH || path.dirname(process.execPath),
+          OPEN_CLAUDIA_TEST: "1",
+          OPEN_CLAUDIA_CONFIG_DIR: configDir,
+          WORKSPACE: workspace,
+          PROJECT_TRANSCRIPTS: "1",
+          PACK_REVIEW: "off",
+        },
+        encoding: "utf8",
+        timeout: 30000,
+        maxBuffer: 2 * 1024 * 1024,
+      });
+      assert.ifError(child.error);
+      assert.strictEqual(child.status, 0, child.stderr || `${mode} failed`);
+      process.stdout.write(child.stdout);
+    }
+    console.log("provider gateway OK");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}

package/test-provider-language.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+const read = (relative) => fs.readFileSync(path.join(__dirname, relative), "utf8");
+
+const manage = read("channels/voice/manage.js");
+assert.doesNotMatch(manage, /DEFAULT_CLAUDE_MODEL/);
+assert.match(manage, /defaultProvider/);
+assert.match(manage, /providerId/);
+assert.match(manage, /defaultModel/);
+
+const cli = read("bin/cli.js");
+assert.match(cli, /inside an Open Claudia agent task/);
+assert.doesNotMatch(cli, /inside a Claude task/i);
+assert.doesNotMatch(cli, /slow health checks \(Claude auth, Telegram API\)/);
+assert.match(cli, /provider auth and channel API checks/);
+
+const web = read("web.js");
+assert.match(web, /Provider credentials/);
+assert.match(web, /Authenticate the coding-agent providers you use/);
+assert.match(web, /Configure channels and coding-agent providers/);
+
+const setup = read("setup.js");
+assert.match(setup, /Your Open Claudia bot is connected/);
+assert.match(setup, /Description=Open Claudia Provider Bot/);
+assert.doesNotMatch(setup, /Your Claude Code bot is connected|Description=Claude Code Telegram Bot/);
+
+const pkg = JSON.parse(read("package.json"));
+assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
+// 3.0.0 approved by Sumeet 2026-07-10 (provider-parity release; CHANGELOG
+// already documents it as v3.0.0).
+assert.strictEqual(pkg.version, "3.0.0", "release version must remain unchanged without explicit approval");
+for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
+  assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
+}
+for (const shipped of ["docs/", "soul.md", "test-provider-language.js"]) {
+  assert.ok(pkg.files.includes(shipped), `package file missing: ${shipped}`);
+}
+assert.match(pkg.scripts.pretest, /node test-provider-language\.js/);
+
+const soul = read("soul.md");
+const runtimeIdentity = soul.split("## About Sumeet")[0];
+assert.match(runtimeIdentity, /Open Claudia running the selected coding-agent provider/);
+assert.doesNotMatch(runtimeIdentity, /bridge to Claude Code|Name: Just "Claude"/i);
+assert.match(soul, /Uses Cursor IDE and Claude Code CLI daily/, "preserve the user-authored Cursor IDE fact");
+
+const readme = read("README.md");
+assert.match(readme, /## Utility provider policy/);
+assert.match(readme, /Foreground turns never silently fall back/);
+assert.match(readme, /## Provider session semantics/);
+assert.match(readme, /capabilit(?:y|ies)/i);
+assert.match(readme, /\[Provider migration snapshots and rollback\]\(docs\/PROVIDER_MIGRATION\.md\)/);
+assert.match(readme, /native same-UID process/i);
+assert.match(readme, /legacy-compatible service id com\.claude-telegram-bot/);
+assert.match(readme, /com\.claude-telegram-bot\.plist/);
+assert.doesNotMatch(readme, /com\.open-claudia\.plist/);
+
+const channelDesign = read("docs/CHANNEL_DESIGN.md");
+assert.match(channelDesign, /provider registry/i);
+assert.match(channelDesign, /PROVIDER_MIGRATION\.md/);
+
+const multiChannelPlan = read("docs/MULTI_CHANNEL_PLAN.md");
+assert.match(multiChannelPlan, /historical design plan/i);
+assert.match(multiChannelPlan, /## 1\. Current implementation/);
+assert.doesNotMatch(multiChannelPlan, /## 1\. Current state \(what we have\)/);
+
+const migration = read("docs/PROVIDER_MIGRATION.md");
+assert.match(migration, /logical path, byte size, schema version, and SHA-256/i);
+assert.match(migration, /post-upgrade changes are not merged/i);
+
+const changelog = read("CHANGELOG.md");
+assert.match(changelog, /^## v3\.0\.0 — provider parity and Cursor removal$/m);
+assert.match(changelog, /^## v2\.15\.0$/m, "historical changelog sections must remain present");
+const release = changelog.slice(
+  changelog.indexOf("## v3.0.0 — provider parity and Cursor removal"),
+  changelog.indexOf("## v2.15.0"),
+);
+assert.match(release, /recommend(?:ed|ation)[^\n]*v3\.0\.0/i);
+assert.match(release, /released as `v3\.0\.0` \(2026-07-10\)/);
+assert.doesNotMatch(release, /remains (?:at )?v?2\.15\.0/i);
+assert.match(release, /authenticated release validation/i);
+assert.match(release, /fresh[^\n]*resum(?:e|ed)[^\n]*read-only plan[^\n]*harmless tool[^\n]*utility JSON[^\n]*prompt-context sentinel/i);
+
+console.log("provider language OK");