@hassangameryt/freeflow 0.7.0 → 0.7.2

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

@@ -0,0 +1,275 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { initialState, reduce, parseRoutingEvent } from "../../dist/cognitive-routing-v2/state.js";
+const pair = { provider: "fixture", modelId: "model", thinking: "off" };
+function machine() {
+  let s = initialState(),
+    n = 0;
+  return {
+    get state() {
+      return s;
+    },
+    event(data) {
+      return {
+        version: 2,
+        eventId: `event-${++n}`,
+        operationId: `op-${n}`,
+        stepId: data.type,
+        recordedSessionId: "session",
+        data,
+      };
+    },
+    apply(data) {
+      const e = this.event(data);
+      s = reduce(s, e);
+      return e;
+    },
+    set(e) {
+      s = reduce(s, e);
+    },
+  };
+}
+const control = (profile) => ({ type: "control", control: "automatic", profile, reason: "fixture control" });
+const opened = (id, profile, assignmentId) => ({
+  type: "execution-opened",
+  execution: { id, profile, assignmentId, basisUserEntryId: "user", pair, resultEntryIds: [] },
+});
+const bound = (id) => ({
+  type: "execution-bound",
+  executionId: id,
+  assistantEntryId: `assistant-${id}`,
+  resultEntryIds: [],
+  outcome: "completed",
+});
+function delegated(id = "a1", unitId = "u1", assignmentIds = [id], executionId = "e1", replacement) {
+  const hid = `d-${id}`;
+  return {
+    type: "delegate-accepted",
+    unit: { id: unitId, objective: "fixture objective", state: "open", assignmentIds },
+    assignment: {
+      id,
+      unitId,
+      contract: "fixture contract",
+      basisUserEntryId: "user",
+      state: "outstanding",
+      delegateHandoffId: hid,
+    },
+    handoff: {
+      id: hid,
+      kind: "delegate",
+      assignmentId: id,
+      text: "fixture contract",
+      from: "coordinator",
+      to: "executor",
+      executionId,
+      toolCallId: `call-${executionId}`,
+      basisUserEntryId: "user",
+      state: "pending",
+      reportRevision: 0,
+      limitations: [],
+    },
+    ...(replacement ? { replacement } : {}),
+  };
+}
+function returned(report = "exact report", revision = 1) {
+  return {
+    type: "return-accepted",
+    handoff: {
+      id: "return",
+      kind: "return",
+      assignmentId: "a1",
+      text: report,
+      from: "executor",
+      to: "coordinator",
+      executionId: "e2",
+      toolCallId: "return-call",
+      basisUserEntryId: "user",
+      state: "pending",
+      reportRevision: revision,
+      outcome: "partial",
+      limitations: ["uncertainty retained"],
+    },
+  };
+}
+function started() {
+  const m = machine();
+  m.apply(control("coordinator"));
+  m.apply(opened("e1", "coordinator"));
+  m.apply(delegated());
+  m.apply(bound("e1"));
+  m.apply({ type: "handoff-state", handoffId: "d-a1", state: "configured", observedPair: pair });
+  return m;
+}
+const reservation = (revision) => ({
+  id: "reservation",
+  selectionRevision: revision,
+  receiver: "coordinator",
+  target: pair,
+  qualification: "fixture",
+  sources: [],
+  maximumInputTokens: 10000,
+  outputReserve: 1000,
+  estimateMethod: "fixture",
+});
+
+test("event identity and operation idempotency reject changed payloads", () => {
+  const m = machine(),
+    e = m.apply(control("coordinator"));
+  const before = m.state;
+  m.set(e);
+  assert.equal(m.state, before);
+  assert.throws(
+    () => m.set({ ...e, data: control("executor") }),
+    (e) => e.code === "event_identity_conflict",
+  );
+  assert.throws(
+    () => m.set({ ...e, eventId: "other", data: control("executor") }),
+    (e) => e.code === "operation_conflict",
+  );
+});
+test("closed nested schemas reject malformed optional handoff and source fields", () => {
+  const m = machine();
+  for (const patch of [{ reason: {} }, { outcome: 123 }, { unexpected: "field" }]) {
+    const data = delegated();
+    Object.assign(data.handoff, patch);
+    assert.throws(
+      () => parseRoutingEvent(m.event(data)),
+      (e) => e.code === "invalid_assignment",
+    );
+  }
+  const data = opened("e", "executor", "a");
+  data.execution.pair = { ...data.execution.pair, extra: "invalid" };
+  assert.throws(
+    () => parseRoutingEvent(m.event(data)),
+    (e) => e.code === "invalid_execution",
+  );
+});
+test("prototype names are bounded malformed events, not raw decoder errors", () => {
+  for (const type of ["constructor", "__proto__", "toString", "unknown"])
+    assert.throws(
+      () =>
+        parseRoutingEvent({
+          version: 2,
+          eventId: "e",
+          operationId: "o",
+          stepId: "s",
+          recordedSessionId: "session",
+          data: { type },
+        }),
+      (e) => e.name === "RoutingError" && e.code === "invalid_event_type",
+    );
+});
+test("outstanding assignments cannot be implicitly replaced", () => {
+  const m = started();
+  assert.throws(
+    () => m.apply(delegated("a2", "u1", ["a1", "a2"])),
+    (e) => e.code === "wrong_control",
+  );
+  m.apply(control("coordinator"));
+  assert.throws(
+    () => m.apply(delegated("a2", "u1", ["a1", "a2"])),
+    (e) => e.code === "assignment_outstanding",
+  );
+  assert.equal(m.state.assignments.size, 1);
+});
+test("replacement retains old assignment and requires old execution to be resolved", () => {
+  const m = started();
+  m.apply(opened("e2", "executor", "a1"));
+  m.apply(control("coordinator"));
+  m.apply(opened("e3", "coordinator", "a1"));
+  const replacement = delegated("a2", "u1", ["a1", "a2"], "e3", {
+    assignmentId: "a1",
+    reason: "current direction changed",
+  });
+  assert.throws(
+    () => m.apply(replacement),
+    (e) => e.code === "unresolved_executor_execution",
+  );
+  m.apply(bound("e2"));
+  m.apply(replacement);
+  assert.equal(m.state.unitId, "u1");
+  assert.equal(m.state.assignments.get("a1").state, "superseded");
+  assert.equal(m.state.assignments.get("a1").contract, "fixture contract");
+  assert.equal(m.state.assignmentId, "a2");
+});
+test("saved report revisions and retries preserve exact earlier events", () => {
+  const m = started();
+  m.apply(opened("e2", "executor", "a1"));
+  const first = m.apply(returned());
+  m.apply({ type: "handoff-state", handoffId: "return", state: "blocked", reason: "fixture gap" });
+  m.apply({
+    type: "handoff-retry-requested",
+    handoffId: "return",
+    attemptId: "retry",
+    executionId: "e2",
+    toolCallId: "retry-call",
+    reportRevision: 1,
+    selectionRevision: 0,
+  });
+  assert.equal(m.state.handoffs.get("return").text, "exact report");
+  assert.equal(m.state.handoffs.get("return").reportRevision, 1);
+  m.apply(returned("revised exact report", 2));
+  assert.equal(m.state.handoffs.get("return").text, "revised exact report");
+  assert.equal([...m.state.events.values()].find((e) => e.eventId === first.eventId).data.handoff.text, "exact report");
+  assert.equal(m.state.assignments.size, 1);
+});
+test("assessment resumption rejects stale selection and preserves suspension on failure", () => {
+  const m = started();
+  m.apply(opened("e2", "executor", "a1"));
+  m.apply(returned());
+  m.apply({
+    type: "selection-changed",
+    assignmentId: "a1",
+    selection: { revision: 1, selected: [], unresolved: [], withdrawals: [] },
+  });
+  m.apply({ type: "handoff-state", handoffId: "return", state: "configured", observedPair: pair });
+  m.apply({
+    type: "assessment-suspended",
+    handoffId: "return",
+    reason: "user-attention",
+    basisUserEntryId: "new-user",
+    problems: [],
+  });
+  assert.throws(
+    () =>
+      m.apply({
+        type: "assessment-resumed",
+        handoffId: "return",
+        basisUserEntryId: "new-user",
+        reservation: reservation(0),
+      }),
+    (e) => e.code === "stale_selection",
+  );
+  assert.equal(m.state.assessment.view, "suspended");
+  m.apply({
+    type: "assessment-resumed",
+    handoffId: "return",
+    basisUserEntryId: "new-user",
+    reservation: reservation(1),
+  });
+  assert.equal(m.state.assessment.view, "active");
+});
+test("accepted closure cannot conceal work; later work creates a new unit", () => {
+  const m = started();
+  m.apply(control("coordinator"));
+  assert.throws(
+    () => m.apply({ type: "unit-closed", unitId: "u1", outcome: "accepted", assessment: "incorrect" }),
+    (e) => e.code === "unfinished_work",
+  );
+  m.apply({
+    type: "unit-closed",
+    unitId: "u1",
+    outcome: "cancelled",
+    assessment: "user stopped work",
+    supersededAssignmentId: "a1",
+  });
+  assert.equal(m.state.units.get("u1").state, "closed");
+  m.apply(opened("e3", "coordinator"));
+  assert.throws(
+    () => m.apply(delegated("a2", "u1", ["a2"], "e3")),
+    (e) => e.code === "closed_unit_reused",
+  );
+  m.apply(delegated("a2", "u2", ["a2"], "e3"));
+  assert.equal(m.state.unitId, "u2");
+  assert.equal(m.state.units.size, 2);
+});

package/pi-extension/tests/context-virtualization/extension.test.js

@@ -169,6 +169,22 @@ function renderComponent(component) {
   return component.render(120).join("\\n");
 }
 
+test("disabled Freeflow Context does not publish an empty oneOf schema", async () => {
+  const cwd = await mkdtemp(join(tmpdir(), "freeflow-context-disabled-schema-"));
+  try {
+    await writeConfig(cwd, {});
+    const harness = createHarness(cwd, []);
+    await harness.handlers.get("session_start")({ reason: "startup" }, harness.ctx);
+
+    const contextTool = harness.tools.find((tool) => tool.name === "freeflow_context");
+    assert.ok(contextTool);
+    assert.deepEqual(contextTool.parameters.properties, {});
+    assert.equal(Object.hasOwn(contextTool.parameters, "oneOf"), false);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
 test("enabled Context Virtualization registers, projects, archives, restores, and reports through commands", async () => {
   const cwd = await mkdtemp(join(tmpdir(), "freeflow-context-extension-"));
   try {

package/pi-extension/tests/fixtures/routing-native.js

@@ -0,0 +1,188 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import freeflow from "../../dist/index.js";
+import { replay } from "../../dist/cognitive-routing-v2/state.js";
+
+export function response(n, calls = [], text = "fixture response") {
+  const output = [
+    {
+      type: "message",
+      id: `msg-${n}`,
+      role: "assistant",
+      status: "completed",
+      content: [{ type: "output_text", text, annotations: [] }],
+    },
+    ...calls.map((c, i) => ({
+      type: "function_call",
+      id: `fc_${n}_${i}`,
+      call_id: `call-${n}-${i}`,
+      name: c.name,
+      arguments: JSON.stringify(c.args),
+    })),
+  ];
+  const events = [{ type: "response.created", response: { id: `r-${n}`, status: "in_progress", output: [] } }];
+  output.forEach((item, i) => {
+    events.push({
+      type: "response.output_item.added",
+      output_index: i,
+      item: item.type === "message" ? { ...item, content: [] } : { ...item, arguments: "" },
+    });
+    if (item.type === "message")
+      events.push({ type: "response.output_text.delta", output_index: i, content_index: 0, delta: text });
+    else
+      events.push(
+        { type: "response.function_call_arguments.delta", output_index: i, delta: item.arguments },
+        { type: "response.function_call_arguments.done", output_index: i, arguments: item.arguments },
+      );
+    events.push({ type: "response.output_item.done", output_index: i, item });
+  });
+  events.push({
+    type: "response.completed",
+    response: {
+      id: `r-${n}`,
+      status: "completed",
+      output,
+      usage: { input_tokens: 10, output_tokens: 10, total_tokens: 20 },
+    },
+  });
+  return new Response(events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join("") + "data: [DONE]\n\n", {
+    status: 200,
+    headers: { "content-type": "text/event-stream" },
+  });
+}
+
+export async function fixture(script, projection = true, after, withUI = true, options = {}) {
+  const root = await mkdtemp(join(tmpdir(), "freeflow-v2-native-"));
+  const cwd = join(root, "cwd"),
+    agentDir = join(root, "agent");
+  await mkdir(join(cwd, ".freeflow"), { recursive: true });
+  await mkdir(agentDir);
+  await writeFile(
+    join(cwd, ".freeflow/config.json"),
+    JSON.stringify({
+      cognitiveRouting: {
+        enabled: true,
+        projection,
+        profiles: {
+          coordinator: { provider: "openai", model: "gpt-4o", thinking: "off" },
+          executor: { provider: "openai", model: "gpt-4.1-mini", thinking: "off" },
+        },
+      },
+    }),
+  );
+  await writeFile(join(cwd, "evidence.txt"), "EXACT_EVIDENCE_BODY_81");
+  await writeFile(join(cwd, "unselected.txt"), "UNSELECTED_PRIVATE_BODY_93");
+  await writeFile(
+    join(agentDir, "models.json"),
+    JSON.stringify({ providers: { openai: { baseUrl: "https://fixture.invalid/v1" } } }),
+  );
+  const priorFetch = globalThis.fetch,
+    offline = process.env.PI_OFFLINE;
+  process.env.PI_OFFLINE = "1";
+  const requests = [],
+    errors = [],
+    contexts = [],
+    transportFailures = [],
+    notices = [];
+  let session;
+  const manager = SessionManager.create(cwd, join(root, "sessions"));
+  globalThis.fetch = async (url, init) => {
+    assert.match(String(url), /^https:\/\/fixture\.invalid\//, "no unexpected network destination");
+    const body = JSON.parse(String(init.body));
+    requests.push(body);
+    assert.ok(requests.length <= (options.maxRequests ?? 15), "bounded fixture request count");
+    try {
+      const calls = await script(requests.length, body, manager, requests);
+      return options.response ? options.response(requests.length, calls) : response(requests.length, calls);
+    } catch (error) {
+      transportFailures.push(error);
+      throw error;
+    }
+  };
+  try {
+    const modelRuntime = await ModelRuntime.create({
+      authPath: join(agentDir, "auth.json"),
+      modelsPath: join(agentDir, "models.json"),
+      modelsStorePath: join(agentDir, "models-store.json"),
+      allowModelNetwork: false,
+    });
+    await modelRuntime.setRuntimeApiKey("openai", "fixture-not-a-real-key");
+    const settingsManager = SettingsManager.inMemory({
+      compaction: { enabled: false, keepRecentTokens: 1, reserveTokens: 1 },
+      retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
+      ...options.settings,
+    });
+    const loader = new DefaultResourceLoader({
+      cwd,
+      agentDir,
+      settingsManager,
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+      extensionFactories: [
+        freeflow,
+        ...(options.extensions ?? []),
+        (pi) => {
+          pi.on("context", (event) => {
+            contexts.push(structuredClone(event.messages));
+          });
+          pi.on("session_before_compact", () => ({
+            compaction: {
+              summary: "Fixture compacted prior work; evidence must come from canonical sources.",
+              firstKeptEntryId: manager.getLeafId(),
+              tokensBefore: 100,
+            },
+          }));
+        },
+      ],
+    });
+    await loader.reload();
+    assert.deepEqual(loader.getExtensions().errors, []);
+    ({ session } = await createAgentSession({
+      cwd,
+      agentDir,
+      modelRuntime,
+      model: modelRuntime.getModel("openai", "gpt-4o"),
+      thinkingLevel: "off",
+      settingsManager,
+      sessionManager: manager,
+      resourceLoader: loader,
+    }));
+    // Public retained bindings make Pi emit session_start again on SDK reload, including headless mode.
+    await session.bindExtensions({
+      mode: "print",
+      onError: (e) => errors.push(e),
+      ...(withUI ? { uiContext: { notify: (...args) => notices.push(args), setStatus: () => {} } } : {}),
+    });
+    await options.onSession?.(session);
+    await session.prompt("Complete the fixture assignment.");
+    await session.waitForIdle();
+    assert.deepEqual(errors, [], "extension lifecycle errors");
+    if (after) await after({ session, manager, requests, contexts, cwd, notices });
+    assert.deepEqual(errors, [], "post-lifecycle errors");
+    assert.deepEqual(transportFailures, [], "scripted provider assertions must not be swallowed as provider errors");
+    assert.notEqual(
+      session.messages.at(-1)?.stopReason,
+      "error",
+      `fixture completes without provider failure: ${session.messages.at(-1)?.errorMessage ?? ""}`,
+    );
+    return { requests, state: replay(manager.getBranch()), entries: manager.getEntries(), contexts };
+  } finally {
+    session?.dispose();
+    globalThis.fetch = priorFetch;
+    if (offline === undefined) delete process.env.PI_OFFLINE;
+    else process.env.PI_OFFLINE = offline;
+    await rm(root, { recursive: true, force: true });
+  }
+}

package/pi-extension/tests/integration/mode-free-core.test.js

@@ -14,7 +14,7 @@ import {
   runtimeContext,
   setSessionCoreOverride,
 } from "../../dist/runtime/runtime-context.js";
-import { PIFLOW_HOST } from "../cognitive-routing/host-fixture.js";
+import { PIFLOW_HOST } from "../fixtures/pi-host.js";
 
 function context(cwd) {
   const notifications = [];
@@ -138,8 +138,9 @@ test("Pi exposes base skills without mode or Skills controls", async () => {
     const { handlers, commands } = loadExtension();
     const ctx = context(cwd);
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.equal(resources.skillPaths.length, 25);
+    assert.equal(resources.skillPaths.length, 24);
     assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/workflow/SKILL.md")));
+    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/skills/tdd/SKILL.md")));
     assert.ok(!resources.skillPaths.some((path) => path.endsWith("/skills/mode-contract/SKILL.md")));
 
     const freeflowCommand = commands.find((command) => command.name === "freeflow");