@hassangameryt/freeflow 0.7.3 → 0.8.0

package/pi-extension/tests/cognitive-routing-v2/render.test.js

@@ -1,244 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { visibleWidth } from "@earendil-works/pi-tui";
-import { renderRoutingCall, renderRoutingResult } from "../../dist/cognitive-routing-v2/render.js";
-
-test("evidence inspection renders metadata and gaps without source previews", () => {
-  const receipt = {
-    count: 1,
-    returned: 1,
-    selected: ["ctx:old"],
-    candidates: [
-      {
-        ref: "ctx:old",
-        kind: "toolResult",
-        producer: "executor",
-        toolName: "read",
-        locator: {
-          callRef: "ctx:call-source",
-          toolCallId: "call-1",
-          label: "read: evidence.txt (offset 1, limit 20)",
-          truncated: false,
-        },
-        assignment: "a1",
-        selected: true,
-        active: false,
-        eligible: true,
-        targetReady: false,
-        preview: "SOURCE_BODY_MUST_NOT_APPEAR",
-        limitations: [{ code: "target_representation", detail: "Required image unsupported" }],
-      },
-    ],
-  };
-  const rendered = renderRoutingResult({ details: receipt }, { expanded: true }, "freeflow_project", {
-    args: { operation: "inspect" },
-  })
-    .render(100)
-    .join("\n");
-  assert.doesNotMatch(rendered, /SOURCE_BODY_MUST_NOT_APPEAR|undefined/);
-  for (const value of [
-    "ctx:old",
-    "executor",
-    "read",
-    "read: evidence.txt (offset 1, limit 20)",
-    "call-1 (ctx:call-source)",
-    "assignment a1",
-    "Required image unsupported",
-  ])
-    assert.ok(rendered.includes(value));
-});
-
-test("expanded receipts retain complete captured reports at narrow and wide widths", () => {
-  const report = "Captured report " + "long evidence with Unicode 界 and words ".repeat(20) + " END_OF_REPORT";
-  const receipt = {
-    status: "accepted",
-    reportSaved: true,
-    transition: "blocked",
-    ready: false,
-    report,
-    evidence: { withdrawals: [{ ref: "ctx:a", reason: "Reason stays visible" }] },
-  };
-  for (const width of [24, 40, 100]) {
-    const lines = renderRoutingResult({ details: receipt }, { expanded: true }).render(width);
-    assert.ok(lines.every((line) => visibleWidth(line) <= width));
-    assert.match(lines.join("\n"), /END_OF_REPORT/);
-    assert.match(lines.join("\n").replace(/\s+/g, " "), /Reason stays visible/);
-    const compact = renderRoutingResult({ details: receipt }, {}).render(width).join("\n");
-    assert.match(compact, /Report saved/);
-    assert.match(compact, /needs correction/);
-    assert.doesNotMatch(compact, /END_OF_REPORT/);
-  }
-});
-
-test("streaming arguments follow the latest six wrapped lines; expansion retains the whole draft", () => {
-  const report = Array.from({ length: 12 }, (_, i) => `Report line ${i + 1}`).join("\n");
-  const live = { argsComplete: false, isPartial: true, expanded: false };
-  const lines = renderRoutingCall("freeflow_return", { operation: "submit", report }, live).render(40);
-  assert.match(lines.join("\n"), /Writing report/);
-  assert.match(lines.join("\n"), /Report line 12/);
-  assert.doesNotMatch(lines.join("\n"), /Report line 1\s/);
-  assert.equal(lines.filter((line) => line.includes("Report line")).length, 6);
-  const full = renderRoutingCall("freeflow_return", { operation: "submit", report }, { ...live, expanded: true })
-    .render(40)
-    .join("\n");
-  assert.match(full, /Report line 1\s/);
-  assert.match(full, /Report line 12/);
-  const done = renderRoutingCall(
-    "freeflow_return",
-    { operation: "submit", report },
-    { ...live, argsComplete: true, isPartial: false },
-  )
-    .render(40)
-    .join("\n");
-  assert.equal(done.trim(), "Return to Coordinator");
-});
-
-test("report streaming is not obscured by limitations sent before or after the report", () => {
-  const limitations = ["First limitation", "Second limitation", "Third limitation"];
-  const live = { isPartial: true, argsComplete: false };
-  for (const reportFirst of [true, false]) {
-    for (const length of [2, 12, 20]) {
-      const report = Array.from({ length }, (_, i) => `Report progress ${i + 1}`).join("\n");
-      const args = reportFirst
-        ? { operation: "submit", report, limitations }
-        : { operation: "submit", limitations, report };
-      const collapsed = renderRoutingCall("freeflow_return", args, live).render(60).join("\n");
-      assert.match(collapsed, new RegExp(`Report progress ${length}`));
-      assert.doesNotMatch(collapsed, /Limitation:/);
-      const expanded = renderRoutingCall("freeflow_return", args, { ...live, expanded: true })
-        .render(60)
-        .join("\n");
-      for (const limit of limitations) assert.ok(expanded.includes(limit));
-      assert.match(expanded, /Report progress 1/);
-    }
-  }
-  assert.doesNotMatch(
-    renderRoutingCall("freeflow_return", { operation: "submit", limitations }, live).render(60).join("\n"),
-    /Limitation:/,
-  );
-});
-
-test("replacement streaming follows the contract without a sticky reason", () => {
-  const reason = "Replacement reason " + "keeps its full explanation. ".repeat(30);
-  const live = { isPartial: true, argsComplete: false };
-  for (const length of [2, 12]) {
-    const contract = Array.from({ length }, (_, i) => `Replacement progress ${i + 1}`).join("\n");
-    for (const args of [
-      { operation: "replace", reason, contract },
-      { operation: "replace", contract, reason },
-    ]) {
-      const compact = renderRoutingCall("freeflow_delegate", args, live).render(60).join("\n");
-      assert.match(compact, new RegExp(`Replacement progress ${length}`));
-      assert.doesNotMatch(compact, /Reason:|Replacement reason/);
-      const expanded = renderRoutingCall("freeflow_delegate", args, { ...live, expanded: true })
-        .render(60)
-        .join("\n");
-      assert.match(expanded, /Reason: Replacement reason/);
-      assert.match(expanded, /Replacement progress 1/);
-    }
-  }
-});
-
-test("completed receipts describe outcomes without protocol state disclaimers", () => {
-  for (const [name, operation, receipt, expected] of [
-    ["freeflow_delegate", "assign", { status: "accepted", transition: "pending" }, "Assignment saved"],
-    ["freeflow_delegate", "replace", { status: "accepted", transition: "pending" }, "Replacement saved"],
-    [
-      "freeflow_return",
-      "submit",
-      { status: "accepted", reportSaved: true, ready: true, transition: "pending" },
-      "Report saved",
-    ],
-    [
-      "freeflow_return",
-      "retry",
-      { status: "accepted", reportSaved: true, reportUnchanged: true, ready: true },
-      "Saved report retained",
-    ],
-    ["freeflow_project", "add", { status: "saved", selected: ["ctx:a", "ctx:b"], ready: true }, "2 sources selected"],
-    ["freeflow_project", "list", { status: "listed", count: 12, selectableCount: 8 }, "12 sources · 8 selectable"],
-    ["freeflow_unit", "close", { status: "closed", outcome: "deferred" }, "Deferred"],
-    ["freeflow_unit", "history", { history: [{}, {}] }, "2 events"],
-    ["freeflow_project", "remove", { selected: ["ctx:b"], items: [{ status: "removed" }] }, "1 removed · 1 remaining"],
-    // Older receipts used withdrawn for selected and unresolved references alike.
-    [
-      "freeflow_project",
-      "remove",
-      { selected: [], items: [{ status: "withdrawn" }] },
-      "1 reference withdrawn · 0 remaining",
-    ],
-    [
-      "freeflow_project",
-      "inspect",
-      { selected: ["ctx:a"], ready: true },
-      "1 source selected · No unresolved references",
-    ],
-    [
-      "freeflow_project",
-      "add",
-      { selected: ["ctx:a"], items: [{ status: "already_selected" }], ready: true },
-      "No changes · 1 source selected",
-    ],
-    ["freeflow_unit", "assess", { status: "resumed", ready: true }, "Evidence prepared"],
-    ["freeflow_unit", "assess", { status: "suspended", ready: false }, "Assessment remains paused"],
-    [
-      "freeflow_unit",
-      "status",
-      { effective: true, activeProfile: "executor", controlMode: "automatic", assignment: { state: "outstanding" } },
-      "Executor · Assignment in progress",
-    ],
-  ]) {
-    const text = renderRoutingResult({ details: receipt }, {}, name, { args: { operation } }).render(100).join("\n");
-    assert.ok(text.includes(expected), text);
-    assert.doesNotMatch(text, /transfer pending|not acceptance|status:/);
-  }
-});
-
-test("preview limits apply after wrapping long text, and interrupted drafts remain inspectable", () => {
-  const args = {
-    operation: "assign",
-    contract: "Unicode 界 and \u001b[32mcoloured\u001b[0m text ".repeat(40) + " FINAL_WORD",
-  };
-  const component = renderRoutingCall("freeflow_delegate", args, { isPartial: true, argsComplete: false });
-  for (const width of [24, 50, 100]) {
-    const lines = component.render(width);
-    assert.ok(lines.every((line) => visibleWidth(line) <= width));
-    assert.ok(lines.length <= 12, "header, hint and six preview rows stay bounded");
-    assert.match(lines.join("\n"), /FINAL_WORD/);
-  }
-  const failed = renderRoutingResult(
-    { content: [{ type: "text", text: "Operation aborted" }] },
-    { expanded: true },
-    "freeflow_delegate",
-    { args },
-  )
-    .render(50)
-    .join("\n");
-  assert.match(failed, /Submitted contract/);
-  assert.match(failed, /FINAL_WORD/);
-});
-test("partial and absent arguments/results render without requiring live runtime state", () => {
-  assert.ok(renderRoutingCall("freeflow_delegate", undefined).render(30).length);
-  assert.match(renderRoutingResult({}, { isPartial: true }).render(30).join(""), /Working/);
-  const inspection = renderRoutingCall(
-    "freeflow_unit",
-    { operation: "inspect", view: "detail", ref: "assignment:existing" },
-    { isPartial: true, argsComplete: false },
-  )
-    .render(60)
-    .join("\n");
-  assert.match(inspection, /View: detail/);
-  assert.match(inspection, /Ref: assignment:existing/);
-});
-
-test("native error results with empty details never look like successful saved assignments", () => {
-  const result = { content: [{ type: "text", text: "Operation aborted" }], details: {} };
-  const rendered = renderRoutingResult(result, {}, "freeflow_delegate", {
-    args: { operation: "assign" },
-    isError: true,
-  })
-    .render(60)
-    .join("\n");
-  assert.match(rendered, /Operation aborted/);
-  assert.doesNotMatch(rendered, /Assignment saved/);
-});

package/pi-extension/tests/cognitive-routing-v2/runtime.test.js

@@ -1,423 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { RoutingRuntime } from "../../dist/cognitive-routing-v2/runtime.js";
-import { EventStore } from "../../dist/session-sources/events.js";
-import { replay } from "../../dist/cognitive-routing-v2/state.js";
-
-const modelIds = ["coordinator", "helper", "executor", "coordinator-fast", "helper-fast", "executor-cheap"];
-const models = Object.fromEntries(
-  modelIds.map((id) => [
-    id,
-    {
-      id,
-      provider: "fixture",
-      api: "fixture",
-      input: ["text"],
-      reasoning: true,
-      contextWindow: 100000,
-      maxTokens: 1000,
-    },
-  ]),
-);
-const cap = {
-  effective: true,
-  enabled: true,
-  projection: false,
-  profiles: Object.fromEntries(
-    ["coordinator", "executor"].map((id) => [id, { provider: "fixture", model: id, thinking: "off" }]),
-  ),
-  blockingReason: { code: "", message: "" },
-};
-const helperCap = {
-  ...cap,
-  delegation: "helper",
-  profiles: Object.fromEntries(
-    ["coordinator", "helper"].map((id) => [id, { provider: "fixture", model: id, thinking: "off" }]),
-  ),
-};
-async function environment(run) {
-  const root = await mkdtemp(join(tmpdir(), "routing-runtime-"));
-  let active;
-  const make = (label) => {
-    const manager = SessionManager.create(root, join(root, label));
-    manager.appendMessage({
-      role: "assistant",
-      content: [{ type: "text", text: "seed" }],
-      model: "coordinator",
-      provider: "fixture",
-      api: "fixture",
-      stopReason: "stop",
-      timestamp: 1,
-    });
-    return {
-      sessionManager: manager,
-      model: models.coordinator,
-      thinkingLevel: "off",
-      failNextModelId: undefined,
-      failNextThinkingLevel: undefined,
-      modelRegistry: { find: (_p, id) => models[id], getApiKeyAndHeaders: async () => ({ ok: true }) },
-      getSystemPrompt: () => "",
-      isIdle: () => true,
-      abort() {},
-    };
-  };
-  const pi = {
-    appendEntry: (type, data) => active.sessionManager.appendCustomEntry(type, data),
-    setModel: async (model) => {
-      if (active.failNextModelId === model.id) {
-        active.failNextModelId = undefined;
-        return false;
-      }
-      active.model = model;
-      return true;
-    },
-    setThinkingLevel: (level) => {
-      if (active.failNextThinkingLevel === level) {
-        active.failNextThinkingLevel = undefined;
-        throw new Error("fixture thinking application failed");
-      }
-      active.thinkingLevel = level;
-    },
-    getAllTools: () => [],
-    sendMessage() {},
-  };
-  const runtime = new RoutingRuntime(pi);
-  try {
-    await run({
-      runtime,
-      make,
-      activate: (ctx) => {
-        active = ctx;
-      },
-      pi,
-    });
-  } finally {
-    runtime.unbind();
-    await rm(root, { recursive: true, force: true });
-  }
-}
-
-test("delayed old control cannot change or poison a newly bound session", async () =>
-  environment(async ({ runtime, make, activate }) => {
-    const a = make("a"),
-      b = make("b");
-    activate(a);
-    await runtime.bind(a, cap);
-    const original = EventStore.prototype.reconcile;
-    let release, entered;
-    const gate = new Promise((r) => {
-      release = r;
-    });
-    const entrance = new Promise((r) => {
-      entered = r;
-    });
-    EventStore.prototype.reconcile = async function () {
-      await original.call(this);
-      if (this.reader === a.sessionManager) {
-        entered();
-        await gate;
-      }
-    };
-    try {
-      const old = runtime.setManualProfile("executor");
-      await entrance;
-      activate(b);
-      await runtime.bind(b, cap);
-      const before = b.sessionManager.getEntries().length;
-      release();
-      assert.equal((await old).status, "blocked");
-      assert.equal(b.sessionManager.getEntries().length, before);
-      assert.equal(b.model.id, "coordinator");
-      assert.equal(runtime.state().runtimeStatus, "active");
-      assert.equal(replay(b.sessionManager.getBranch()).control, "automatic");
-    } finally {
-      release();
-      EventStore.prototype.reconcile = original;
-    }
-  }));
-
-for (const [name, firstCapability, heldWorker, secondCapability] of [
-  ["Helper to Executor", helperCap, "helper", cap],
-  ["Executor to Helper", cap, "executor", helperCap],
-]) {
-  test(`binding a fresh ${name} session does not inherit the prior manual hold`, async () =>
-    environment(async ({ runtime, make, activate }) => {
-      const first = make(`${name}-first`);
-      activate(first);
-      await runtime.bind(first, firstCapability);
-      assert.equal((await runtime.setManualProfile(heldWorker)).status, "active");
-      const firstEntryCount = first.sessionManager.getEntries().length;
-
-      const second = make(`${name}-second`);
-      activate(second);
-      await runtime.bind(second, secondCapability);
-
-      assert.equal(runtime.state().runtimeStatus, "active");
-      assert.equal(runtime.state().controlMode, "automatic");
-      assert.equal(runtime.state().activeProfile, "coordinator");
-      assert.equal(second.model.id, "coordinator");
-      assert.equal(first.sessionManager.getEntries().length, firstEntryCount);
-      assert.equal(replay(first.sessionManager.getBranch()).control, "manual");
-      assert.equal(replay(first.sessionManager.getBranch()).profile, heldWorker);
-    }));
-}
-
-test("settled unbound attempt is retired truthfully and next request has a new identity", async () =>
-  environment(async ({ runtime, make, activate }) => {
-    const ctx = make("interrupt");
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    const first = { role: "user", content: "one", timestamp: 2 };
-    ctx.sessionManager.appendMessage(first);
-    await runtime.context(ctx, [first]);
-    const assistant = {
-      role: "assistant",
-      content: [{ type: "toolCall", id: "call", name: "read", arguments: {} }],
-      timestamp: 3,
-    };
-    runtime.messageEnd(assistant);
-    ctx.sessionManager.appendMessage(assistant);
-    runtime.preflight({ toolName: "read", toolCallId: "call" }, ctx);
-    const old = [...replay(ctx.sessionManager.getBranch()).executions.values()][0];
-    await runtime.settled(ctx);
-    const retired = replay(ctx.sessionManager.getBranch()).executions.get(old.id);
-    assert.match(retired.interrupted, /unresolved/);
-    assert.equal(retired.assistantEntryId, undefined);
-    const second = { role: "user", content: "two", timestamp: 4 };
-    ctx.sessionManager.appendMessage(second);
-    await runtime.context(ctx, [first, assistant, second]);
-    const next = {
-      role: "assistant",
-      content: [{ type: "toolCall", id: "next", name: "read", arguments: {} }],
-      timestamp: 5,
-    };
-    runtime.messageEnd(next);
-    ctx.sessionManager.appendMessage(next);
-    runtime.preflight({ toolName: "read", toolCallId: "next" }, ctx);
-    const executions = [...replay(ctx.sessionManager.getBranch()).executions.values()];
-    assert.equal(executions.length, 2);
-    assert.notEqual(executions[1].id, old.id);
-    assert.notEqual(executions[1].basisUserEntryId, old.basisUserEntryId);
-  }));
-
-test("session profile overrides apply only to the selected pair and restore configured pairs", async () =>
-  environment(async ({ runtime, make, activate }) => {
-    const ctx = make("session-profile");
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    assert.equal(ctx.model.id, "coordinator");
-
-    const coordinatorOverride = await runtime.setSessionProfileOverride("coordinator", {
-      provider: "fixture",
-      modelId: "coordinator-fast",
-      thinking: "high",
-    });
-    assert.equal(coordinatorOverride.status, "active");
-    assert.equal(ctx.model.id, "coordinator-fast");
-    assert.equal(ctx.thinkingLevel, "high");
-    assert.deepEqual(replay(ctx.sessionManager.getBranch()).profileOverrides.get("coordinator"), {
-      provider: "fixture",
-      modelId: "coordinator-fast",
-      thinking: "high",
-    });
-
-    const executorOverride = await runtime.setSessionProfileOverride("executor", {
-      provider: "fixture",
-      modelId: "executor-cheap",
-      thinking: "low",
-    });
-    assert.equal(executorOverride.status, "stored");
-    assert.equal(ctx.model.id, "coordinator-fast");
-    assert.equal(ctx.thinkingLevel, "high");
-
-    runtime.unbind();
-    ctx.model = models.coordinator;
-    ctx.thinkingLevel = "off";
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    assert.equal(ctx.model.id, "coordinator-fast");
-    assert.equal(ctx.thinkingLevel, "high");
-
-    const held = await runtime.setManualProfile("executor");
-    assert.equal(held.status, "active");
-    assert.equal(ctx.model.id, "executor-cheap");
-    assert.equal(ctx.thinkingLevel, "low");
-
-    ctx.model = models.executor;
-    ctx.thinkingLevel = "off";
-    await runtime.ancestryChanged(ctx, false);
-    assert.equal(ctx.model.id, "executor-cheap");
-    assert.equal(ctx.thinkingLevel, "low");
-    assert.equal(runtime.state().controlMode, "manual-executor");
-
-    const inheritedExecutor = await runtime.setSessionProfileOverride("executor", null);
-    assert.equal(inheritedExecutor.status, "active");
-    assert.equal(ctx.model.id, "executor");
-    assert.equal(ctx.thinkingLevel, "off");
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.has("coordinator"), true);
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.has("executor"), false);
-
-    const reset = await runtime.resetSessionProfileOverrides();
-    assert.equal(reset.status, "stored");
-    assert.equal(ctx.model.id, "executor");
-    assert.equal(ctx.thinkingLevel, "off");
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.size, 0);
-    assert.equal(runtime.state().controlMode, "manual-executor");
-
-    runtime.unbind();
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    assert.equal(ctx.model.id, "executor");
-  }));
-
-test("Helper session presets apply through the same guarded profile path", async () =>
-  environment(async ({ runtime, make, activate }) => {
-    const ctx = make("session-helper-profile");
-    activate(ctx);
-    await runtime.bind(ctx, helperCap);
-    const helperOverride = { provider: "fixture", modelId: "helper-fast", thinking: "high" };
-    assert.equal((await runtime.setSessionProfileOverride("helper", helperOverride)).status, "stored");
-    assert.equal(ctx.model.id, "coordinator");
-    assert.equal((await runtime.setManualProfile("helper")).status, "active");
-    assert.equal(ctx.model.id, "helper-fast");
-    assert.equal(ctx.thinkingLevel, "high");
-    assert.deepEqual(replay(ctx.sessionManager.getBranch()).profileOverrides.get("helper"), helperOverride);
-    assert.equal((await runtime.resetSessionProfileOverrides()).status, "active");
-    assert.equal(ctx.model.id, "helper");
-    assert.equal(ctx.thinkingLevel, "off");
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.size, 0);
-    assert.equal(runtime.state().controlMode, "manual-helper");
-  }));
-
-test("manual control rejects a disabled worker without poisoning routing", async () =>
-  environment(async ({ runtime, make, activate }) => {
-    const ctx = make("disabled-manual-worker");
-    activate(ctx);
-    await runtime.bind(ctx, helperCap);
-    const result = await runtime.setManualProfile("executor");
-    assert.equal(result.status, "blocked");
-    assert.match(result.reason, /not enabled/);
-    assert.equal(runtime.state().runtimeStatus, "active");
-    assert.equal(runtime.state().activeProfile, "coordinator");
-    assert.equal(ctx.model.id, "coordinator");
-  }));
-
-test("invalid session profile overrides preserve the native pair and routing state", async () =>
-  environment(async ({ runtime, make, activate }) => {
-    const ctx = make("session-invalid");
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    const beforeEntries = ctx.sessionManager.getEntries().length;
-    const result = await runtime.setSessionProfileOverride("coordinator", {
-      provider: "fixture",
-      modelId: "missing-model",
-      thinking: "high",
-    });
-    assert.equal(result.status, "blocked");
-    assert.equal(ctx.model.id, "coordinator");
-    assert.equal(ctx.thinkingLevel, "off");
-    assert.equal(ctx.sessionManager.getEntries().length, beforeEntries);
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.size, 0);
-  }));
-
-test("rebind rejects a persisted session override when its model is unavailable", async () =>
-  await environment(async ({ runtime, make, activate }) => {
-    const ctx = make("session-stale");
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    assert.equal(
-      (
-        await runtime.setSessionProfileOverride("coordinator", {
-          provider: "fixture",
-          modelId: "coordinator-fast",
-          thinking: "high",
-        })
-      ).status,
-      "active",
-    );
-    runtime.unbind();
-    const saved = models["coordinator-fast"];
-    delete models["coordinator-fast"];
-    try {
-      ctx.model = models.coordinator;
-      ctx.thinkingLevel = "off";
-      activate(ctx);
-      await runtime.bind(ctx, cap);
-      assert.equal(runtime.state().runtimeStatus, "blocked");
-      assert.match(runtime.state().runtimeReason, /profile_unavailable|Model unavailable/);
-    } finally {
-      models["coordinator-fast"] = saved;
-    }
-    const corrected = await runtime.setSessionProfileOverride("coordinator", null);
-    assert.equal(corrected.status, "active");
-    assert.equal(runtime.state().runtimeStatus, "active");
-    assert.equal(ctx.model.id, "coordinator");
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.size, 0);
-  }));
-
-test("failed active session override restores the prior pair and event state", async () =>
-  await environment(async ({ runtime, make, activate }) => {
-    const ctx = make("session-rollback");
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    assert.equal(
-      (
-        await runtime.setSessionProfileOverride("coordinator", {
-          provider: "fixture",
-          modelId: "coordinator-fast",
-          thinking: "high",
-        })
-      ).status,
-      "active",
-    );
-    ctx.failNextModelId = "coordinator";
-    const result = await runtime.setSessionProfileOverride("coordinator", null);
-    assert.equal(result.status, "blocked");
-    assert.equal(ctx.model.id, "coordinator-fast");
-    assert.equal(ctx.thinkingLevel, "high");
-    assert.deepEqual(replay(ctx.sessionManager.getBranch()).profileOverrides.get("coordinator"), {
-      provider: "fixture",
-      modelId: "coordinator-fast",
-      thinking: "high",
-    });
-  }));
-
-test("active session reset restores the configured pair and control mode", async () =>
-  await environment(async ({ runtime, make, activate }) => {
-    const ctx = make("session-active-reset");
-    activate(ctx);
-    await runtime.bind(ctx, cap);
-    const override = { provider: "fixture", modelId: "coordinator-fast", thinking: "high" };
-    assert.equal((await runtime.setSessionProfileOverride("coordinator", override)).status, "active");
-    const result = await runtime.resetSessionProfileOverrides();
-    assert.equal(result.status, "active");
-    assert.equal(ctx.model.id, "coordinator");
-    assert.equal(ctx.thinkingLevel, "off");
-    assert.equal(replay(ctx.sessionManager.getBranch()).profileOverrides.size, 0);
-    assert.equal(runtime.state().controlMode, "automatic");
-  }));
-
-for (const operation of ["clear", "reset"]) {
-  test(`partial active ${operation} failure restores the prior native pair and override`, async () =>
-    await environment(async ({ runtime, make, activate }) => {
-      const ctx = make(`session-partial-${operation}`);
-      activate(ctx);
-      await runtime.bind(ctx, cap);
-      const override = { provider: "fixture", modelId: "coordinator-fast", thinking: "high" };
-      assert.equal((await runtime.setSessionProfileOverride("coordinator", override)).status, "active");
-      ctx.failNextThinkingLevel = "off";
-      const result =
-        operation === "clear"
-          ? await runtime.setSessionProfileOverride("coordinator", null)
-          : await runtime.resetSessionProfileOverrides();
-      assert.equal(result.status, "blocked");
-      assert.equal(ctx.model.id, "coordinator-fast");
-      assert.equal(ctx.thinkingLevel, "high");
-      assert.deepEqual(replay(ctx.sessionManager.getBranch()).profileOverrides.get("coordinator"), override);
-      assert.equal(runtime.state().runtimeStatus, "blocked");
-    }));
-}