@hassangameryt/freeflow 0.7.1 → 0.7.3

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

@@ -0,0 +1,244 @@
+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

@@ -0,0 +1,423 @@
+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");
+    }));
+}