@hassangameryt/freeflow 0.7.1 → 0.7.2

package/pi-extension/tests/cognitive-routing/profile-resolution.test.js

@@ -1,279 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import { resolveCognitiveRoutingConfig } from "../../dist/cognitive-routing/config.js";
-import { resolveCognitiveRoutingState } from "../../dist/cognitive-routing/runtime.js";
-import { readCapabilityState } from "../../dist/runtime/runtime-context.js";
-import { PIFLOW_HOST } from "./host-fixture.js";
-
-const standard = {
-  provider: "openai-codex",
-  model: "gpt-5.6-luna",
-  thinkingLevel: "high",
-};
-const reasoning = {
-  provider: "openai-codex",
-  model: "gpt-5.6-sol",
-  thinkingLevel: "max",
-};
-
-function configuredRepository(overrides = {}) {
-  return {
-    cognitiveRouting: {
-      enabled: true,
-      profiles: { standard, reasoning },
-      ...overrides,
-    },
-  };
-}
-
-function createHost({ models = [], unauthenticated = [], clamps = {} } = {}) {
-  const modelMap = new Map(models.map((model) => [`${model.provider}/${model.id}`, model]));
-  const unauthenticatedSet = new Set(unauthenticated);
-  return {
-    modelRegistry: {
-      find(provider, modelId) {
-        return modelMap.get(`${provider}/${modelId}`);
-      },
-      async getApiKeyAndHeaders(model) {
-        return unauthenticatedSet.has(model.provider) ? { ok: false, error: "missing credentials" } : { ok: true };
-      },
-      clampThinkingLevel(model, level) {
-        return clamps[`${model.provider}/${model.id}`]?.[level] ?? level;
-      },
-    },
-  };
-}
-
-const standardModel = { provider: standard.provider, id: standard.model };
-const reasoningModel = { provider: reasoning.provider, id: reasoning.model };
-
-test("resolves two complete repository profiles", () => {
-  const result = resolveCognitiveRoutingConfig(configuredRepository(), {});
-
-  assert.equal(result.valid, true);
-  assert.equal(result.enabled, true);
-  assert.equal(result.enabledSource, "repository");
-  assert.deepEqual(result.profiles, { standard, reasoning });
-  assert.deepEqual(result.profileSources, { standard: "repository", reasoning: "repository" });
-});
-
-test("defaults new-session Cognitive Routing to automatic Reasoning control", () => {
-  const result = resolveCognitiveRoutingConfig(configuredRepository(), {});
-
-  assert.deepEqual(result.sessionStart, { control: "automatic", profile: "reasoning" });
-  assert.deepEqual(result.sessionStartSources, { control: "default", profile: "default" });
-});
-
-test("canonicalizes automatic session starts to Reasoning", () => {
-  const result = resolveCognitiveRoutingConfig(
-    configuredRepository({ sessionStart: { control: "automatic", profile: "standard" } }),
-    {},
-  );
-
-  assert.deepEqual(result.sessionStart, { control: "automatic", profile: "reasoning" });
-  assert.deepEqual(result.sessionStartSources, { control: "repository", profile: "default" });
-});
-
-test("layers session-start control and profile independently", () => {
-  const result = resolveCognitiveRoutingConfig(
-    configuredRepository({ sessionStart: { control: "automatic", profile: "standard" } }),
-    { cognitiveRouting: { sessionStart: { control: "manual", profile: "reasoning" } } },
-  );
-
-  assert.deepEqual(result.sessionStart, { control: "manual", profile: "reasoning" });
-  assert.deepEqual(result.sessionStartSources, { control: "personal", profile: "personal" });
-
-  const inheritedProfile = resolveCognitiveRoutingConfig(
-    configuredRepository({ sessionStart: { control: "manual" } }),
-    { cognitiveRouting: { sessionStart: { profile: "reasoning" } } },
-  );
-  assert.deepEqual(inheritedProfile.sessionStart, { control: "manual", profile: "reasoning" });
-  assert.deepEqual(inheritedProfile.sessionStartSources, { control: "repository", profile: "personal" });
-});
-
-test("replaces a profile atomically from the personal layer", () => {
-  const personalStandard = {
-    provider: "openai-codex",
-    model: "gpt-5.6-luna-personal",
-    thinkingLevel: "medium",
-  };
-  const result = resolveCognitiveRoutingConfig(configuredRepository(), {
-    cognitiveRouting: { profiles: { standard: personalStandard } },
-  });
-
-  assert.equal(result.valid, true);
-  assert.deepEqual(result.profiles.standard, personalStandard);
-  assert.deepEqual(result.profiles.reasoning, reasoning);
-  assert.deepEqual(result.profileSources, { standard: "personal", reasoning: "repository" });
-});
-
-test("rejects a partial personal profile instead of merging fields", () => {
-  const result = resolveCognitiveRoutingConfig(configuredRepository(), {
-    cognitiveRouting: { profiles: { standard: { model: "personal-only" } } },
-  });
-
-  assert.equal(result.valid, false);
-  assert.equal(result.error.code, "invalid_profile");
-  assert.equal(result.error.profile, "standard");
-});
-
-test("keeps Cognitive Routing disabled by default without a config block", async () => {
-  const result = await resolveCognitiveRoutingState({}, {}, createHost({ models: [standardModel, reasoningModel] }));
-
-  assert.equal(result.configured, false);
-  assert.equal(result.enabled, false);
-  assert.equal(result.effective, false);
-  assert.equal(result.blockingReason.code, "disabled");
-});
-
-test("fails only Cognitive Routing closed when its config is invalid", async () => {
-  const result = await resolveCognitiveRoutingState(
-    { cognitiveRouting: { enabled: true, profiles: { standard: { provider: "only-provider" } } } },
-    {},
-    createHost({ models: [standardModel, reasoningModel] }),
-  );
-
-  assert.equal(result.configured, true);
-  assert.equal(result.configValid, false);
-  assert.equal(result.effective, false);
-  assert.equal(result.blockingReason.code, "config_invalid");
-});
-
-test("reports an unsupported host without weakening core capability state", async () => {
-  const result = await resolveCognitiveRoutingState(configuredRepository(), {}, undefined);
-
-  assert.equal(result.enabled, true);
-  assert.equal(result.effective, false);
-  assert.equal(result.blockingReason.code, "host_unsupported");
-});
-
-test("preflights exact identities, authentication, and effective thinking levels", async () => {
-  const host = createHost({
-    models: [standardModel, reasoningModel],
-    clamps: { "openai-codex/gpt-5.6-luna": { high: "high" }, "openai-codex/gpt-5.6-sol": { max: "max" } },
-  });
-  const result = await resolveCognitiveRoutingState(configuredRepository(), {}, host);
-
-  assert.equal(result.effective, true);
-  assert.deepEqual(result.resolvedProfiles.standard, {
-    ...standard,
-    effectiveThinkingLevel: "high",
-  });
-  assert.deepEqual(result.resolvedProfiles.reasoning, {
-    ...reasoning,
-    effectiveThinkingLevel: "max",
-  });
-});
-
-test("normal Pi preflight resolves thinking levels from model metadata without a registry clamp", async () => {
-  const models = [
-    {
-      provider: standard.provider,
-      id: standard.model,
-      reasoning: true,
-      thinkingLevelMap: { xhigh: "xhigh", max: "max" },
-    },
-    {
-      provider: reasoning.provider,
-      id: reasoning.model,
-      reasoning: true,
-      thinkingLevelMap: { xhigh: "xhigh", max: "max" },
-    },
-  ];
-  const modelMap = new Map(models.map((model) => [`${model.provider}/${model.id}`, model]));
-  const host = {
-    modelRegistry: {
-      find(provider, modelId) {
-        return modelMap.get(`${provider}/${modelId}`);
-      },
-      async getApiKeyAndHeaders() {
-        return { ok: true };
-      },
-    },
-  };
-
-  const result = await resolveCognitiveRoutingState(configuredRepository(), {}, host);
-
-  assert.equal(result.effective, true);
-  assert.equal(result.resolvedProfiles.standard.effectiveThinkingLevel, "high");
-  assert.equal(result.resolvedProfiles.reasoning.effectiveThinkingLevel, "max");
-});
-
-test("runtime context isolates invalid Cognitive Routing from core Freeflow state", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-"));
-  await mkdir(join(cwd, ".freeflow"));
-  const host = createHost({ models: [standardModel, reasoningModel] });
-  try {
-    await writeFile(
-      join(cwd, ".freeflow", "config.json"),
-      JSON.stringify({ cognitiveRouting: configuredRepository().cognitiveRouting }),
-    );
-    let state = await readCapabilityState(cwd, host, PIFLOW_HOST);
-    assert.equal(state.configured, true);
-    assert.equal(state.enabled, true);
-    assert.equal(state.cognitiveRouting.effective, true);
-
-    await writeFile(
-      join(cwd, ".freeflow", "config.json"),
-      JSON.stringify({ enabled: false, cognitiveRouting: configuredRepository().cognitiveRouting }),
-    );
-    state = await readCapabilityState(cwd, host, PIFLOW_HOST);
-    assert.equal(state.enabled, false);
-    assert.equal(state.cognitiveRouting.enabled, false);
-    assert.equal(state.cognitiveRouting.effective, false);
-    assert.equal(state.cognitiveRouting.blockingReason.code, "disabled");
-
-    await writeFile(
-      join(cwd, ".freeflow", "config.json"),
-      JSON.stringify({
-        cognitiveRouting: { enabled: true, profiles: { standard: { provider: "only-provider" } } },
-      }),
-    );
-    state = await readCapabilityState(cwd, host, PIFLOW_HOST);
-    assert.equal(state.configured, true);
-    assert.equal(state.enabled, true);
-    assert.equal(state.cognitiveRouting.configValid, false);
-    assert.equal(state.cognitiveRouting.effective, false);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("rejects unavailable, unauthenticated, weakened, and identical profile pairs", async () => {
-  const unavailable = await resolveCognitiveRoutingState(
-    configuredRepository(),
-    {},
-    createHost({ models: [standardModel] }),
-  );
-  assert.equal(unavailable.blockingReason.code, "profile_unavailable");
-  assert.equal(unavailable.blockingReason.profile, "reasoning");
-
-  const unauthenticated = await resolveCognitiveRoutingState(
-    configuredRepository(),
-    {},
-    createHost({ models: [standardModel, reasoningModel], unauthenticated: ["openai-codex"] }),
-  );
-  assert.equal(unauthenticated.blockingReason.code, "profile_unauthenticated");
-  assert.equal(unauthenticated.blockingReason.profile, "standard");
-
-  const weakened = await resolveCognitiveRoutingState(
-    configuredRepository(),
-    {},
-    createHost({
-      models: [standardModel, reasoningModel],
-      clamps: { "openai-codex/gpt-5.6-luna": { high: "medium" } },
-    }),
-  );
-  assert.equal(weakened.blockingReason.code, "profile_clamped");
-  assert.equal(weakened.blockingReason.profile, "standard");
-
-  const identical = await resolveCognitiveRoutingState(
-    configuredRepository({ profiles: { standard, reasoning: { ...standard } } }),
-    {},
-    createHost({ models: [standardModel] }),
-  );
-  assert.equal(identical.blockingReason.code, "profiles_identical");
-});

package/pi-extension/tests/cognitive-routing/tool.test.js

@@ -1,230 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  COGNITIVE_ROUTING_HISTORY_TOOL_NAME,
-  COGNITIVE_ROUTING_SWITCH_TOOL_NAME,
-  registerCognitiveRoutingHistoryTool,
-  registerCognitiveRoutingTool,
-} from "../../dist/cognitive-routing/tool.js";
-
-function register(getController) {
-  let tool;
-  registerCognitiveRoutingTool(
-    {
-      registerTool(candidate) {
-        tool = candidate;
-      },
-    },
-    getController,
-  );
-  return tool;
-}
-
-function registerHistory(getHistory) {
-  let tool;
-  registerCognitiveRoutingHistoryTool(
-    {
-      registerTool(candidate) {
-        tool = candidate;
-      },
-    },
-    getHistory,
-  );
-  return tool;
-}
-
-test("exposes exactly the bounded profile switch schema", () => {
-  const tool = register(() => undefined);
-
-  assert.equal(tool.name, COGNITIVE_ROUTING_SWITCH_TOOL_NAME);
-  assert.deepEqual(tool.parameters.required, ["target", "reason"]);
-  assert.deepEqual(tool.parameters.properties.target.enum, ["standard", "reasoning"]);
-  assert.equal(tool.parameters.properties.reason.maxLength, 160);
-});
-
-test("validates reason before any controller call", async () => {
-  const tool = register(() => undefined);
-
-  const result = await tool.execute(
-    "call-1",
-    { target: "reasoning", reason: "line one\nline two" },
-    undefined,
-    undefined,
-    {},
-  );
-
-  assert.deepEqual(result.details.result, { status: "blocked", reason: "reason_must_be_single_line" });
-});
-
-test("blocks stale or manually held execution without host mutation", async () => {
-  let calls = 0;
-  const controller = {
-    state() {
-      return { effective: true, controlMode: "manual-reasoning" };
-    },
-    async switchAutomaticProfile() {
-      calls += 1;
-      return { status: "active", profile: "standard" };
-    },
-  };
-  const tool = register(() => controller);
-
-  const result = await tool.execute(
-    "call-2",
-    { target: "standard", reason: "Need a simpler pass." },
-    undefined,
-    undefined,
-    {},
-  );
-
-  assert.deepEqual(result.details.result, { status: "blocked", reason: "manual_hold" });
-  assert.equal(calls, 0);
-});
-
-test("renders no-op results as already active", () => {
-  const tool = register(() => undefined);
-  const theme = {
-    fg(_color, text) {
-      return text;
-    },
-  };
-
-  assert.equal(
-    tool
-      .renderResult(
-        {
-          details: {
-            result: {
-              status: "active",
-              changed: false,
-              from: "reasoning",
-              to: "reasoning",
-              profile: "reasoning",
-            },
-          },
-        },
-        {},
-        theme,
-      )
-      .render(120)
-      .join("\n"),
-    "Cognitive Routing: reasoning (already active)",
-  );
-});
-
-test("recovers a structured result from model-visible tool text", () => {
-  const tool = register(() => undefined);
-  const theme = {
-    fg(_color, text) {
-      return text;
-    },
-  };
-
-  assert.equal(
-    tool
-      .renderResult(
-        { content: [{ type: "text", text: "freeflow_switch_profile|active\\nprofile|reasoning" }], isError: false },
-        {},
-        theme,
-      )
-      .render(120)
-      .join("\n"),
-    "Cognitive Routing: active · reasoning",
-  );
-});
-
-test("hides the duplicate pending line without reading mutable controller state", () => {
-  const tool = register(() => {
-    throw new Error("renderCall must not read live profile state");
-  });
-  const theme = {
-    fg(_color, text) {
-      return text;
-    },
-  };
-
-  assert.deepEqual(tool.renderCall({ target: "reasoning" }, theme).render(120), []);
-  assert.equal(
-    tool
-      .renderResult(
-        {
-          details: {
-            result: {
-              status: "active",
-              changed: true,
-              from: "standard",
-              to: "reasoning",
-              profile: "reasoning",
-            },
-          },
-        },
-        {},
-        theme,
-      )
-      .render(120)
-      .join("\n"),
-    "Cognitive Routing: standard → reasoning",
-  );
-});
-
-test("exposes the read-only Cognitive Routing history tool contract", async () => {
-  const calls = [];
-  const resultValue = {
-    current: { control: "automatic", profile: "reasoning" },
-    summary: { latestSemanticEventId: "intent-1", unresolvedCount: 0, anomalyCount: 0 },
-    events: [],
-  };
-  const tool = registerHistory((options) => {
-    calls.push(options);
-    return resultValue;
-  });
-
-  assert.equal(tool.name, COGNITIVE_ROUTING_HISTORY_TOOL_NAME);
-  assert.deepEqual(tool.parameters.required, []);
-  assert.deepEqual(tool.parameters.properties.scope.enum, ["session", "active-branch"]);
-  assert.equal(tool.parameters.properties.limit.minimum, 1);
-
-  const result = await tool.execute(
-    "history-1",
-    { scope: "active-branch", anomaliesOnly: true, limit: 7 },
-    undefined,
-    undefined,
-    {},
-  );
-
-  assert.deepEqual(calls, [{ scope: "active-branch", anomaliesOnly: true, limit: 7 }]);
-  assert.deepEqual(result.details.result, resultValue);
-  assert.match(result.content[0].text, /Cognitive Routing history/);
-});
-
-test("routes a valid automatic request through the controller", async () => {
-  const calls = [];
-  const controller = {
-    state() {
-      return { effective: true, controlMode: "automatic" };
-    },
-    async switchAutomaticProfile(target, reason) {
-      calls.push([target, reason]);
-      return { status: "active", changed: true, from: "standard", to: target, profile: target };
-    },
-  };
-  const tool = register(() => controller);
-
-  const result = await tool.execute(
-    "call-3",
-    { target: "reasoning", reason: "Need a deeper analysis. " },
-    undefined,
-    undefined,
-    {},
-  );
-
-  assert.deepEqual(calls, [["reasoning", "Need a deeper analysis."]]);
-  assert.deepEqual(result.details.result, {
-    status: "active",
-    changed: true,
-    from: "standard",
-    to: "reasoning",
-    profile: "reasoning",
-  });
-  assert.match(result.content[0].text, /profile\|reasoning/);
-});

package/skills/tdd/SKILL.md

@@ -1,143 +0,0 @@
----
-name: tdd
-description: Use when implementing or changing settled behavior test-first, reproducing a bug through regression evidence, or protecting existing behavior before a refactor.
----
-
-# Test-Driven Development
-
-Use one observed failing behavior check to guide the smallest complete implementation for one settled behavior.
-
-TDD provides test-first behavior discipline. It does not define intended behavior, authorize test or production effects, select or close a Slice, or prove claims beyond its observing boundary.
-
-One behavior loop is one coherent method result. It may contain several reads, edits, commands, and focused checks. Finish and return one behavior before starting another.
-
-## Enter With Settled Behavior
-
-Before RED, establish:
-
-- the accepted behavior and caller-visible result;
-- relevant success and failure semantics;
-- the boundary where the behavior must hold;
-- authority covering both the check and production effects;
-- the expected reason RED should fail.
-
-Return unsettled behavior, source conflicts, or user-owned choices to [Workflow](../workflow/SKILL.md). Do not encode a guess as a test.
-
-Use TDD for:
-
-- accepted behavior changes;
-- bug corrections with a supported cause or reliable regression loop;
-- consequential logic whose contract benefits from executable evidence;
-- characterization needed before a protected refactor.
-
-Do not force TDD onto documentation, static content, formatting, generated output, or a disposable prototype that is not selected production behavior.
-
-When a bug lacks a supported cause or reliable reproduction, use [Diagnose Failure](../diagnose-failure/SKILL.md) before selecting a production correction.
-
-## Design The Behavior Check
-
-Before designing or materially changing the check, read [Test Design](references/test-design.md).
-
-Name:
-
-- the behavior concept;
-- the stable caller-visible seam;
-- an oracle independent from the implementation;
-- the expected missing behavior RED should expose;
-- the focused and affected boundaries that must be rerun after GREEN.
-
-Use the smallest test environment that still exercises the real behavior and relevant failure path. Do not choose a smaller boundary that mocks away the claim or a larger one that adds noise without proving more.
-
-Keep one behavior concept per loop. Several assertions are appropriate when they jointly describe one outcome.
-
-## Follow The Behavior Loop
-
-```text
-[Settled accepted behavior]
--> [Choose stable seam and independent oracle]
--> [RED: write and run the smallest behavior check]
-   -> fails for the intended missing behavior -> GREEN
-   -> passes immediately -> inspect test, boundary, and existing behavior
-   -> errors or fails elsewhere -> correct the harness or diagnose
--> [GREEN: implement the smallest complete behavior]
--> [Run the focused behavior check]
--> [REFACTOR locally when useful]
--> [Rerun the original path and affected boundary]
--> [Return the method result and evidence]
-```
-
-Do not write all tests first and implementation later. Finish one behavior loop before another.
-
-## Observe Valid RED
-
-Run RED before changing production behavior.
-
-RED is valid only when:
-
-- the check executes through the intended seam;
-- its assertion represents accepted behavior;
-- it fails because the behavior is missing or incorrect;
-- unrelated syntax, setup, environment, or fixture failures do not explain it.
-
-If the check passes immediately, inspect whether:
-
-- the behavior already exists;
-- the assertion is ineffective;
-- the observing boundary is wrong;
-- the test is reproducing a nearby path rather than the reported behavior.
-
-Do not proceed automatically to GREEN.
-
-Correct a clear local harness defect. When the failure remains unexplained or repeated harness changes do not establish valid RED, return to Diagnose Failure.
-
-## Implement Complete GREEN
-
-Before changing production code, read [Code Practices](../execute-work/references/code-practices.md).
-
-Implement the smallest complete behavior that satisfies the accepted contract—not merely the visible assertion.
-
-Do not:
-
-- weaken or rewrite a valid test to obtain GREEN;
-- calculate expected values through production logic;
-- add public hooks, states, flags, or branches used only by tests;
-- silently invent fallback, retry, recovery, or edge-case behavior;
-- broaden implementation into another accepted behavior.
-
-If GREEN requires an unsettled behavior, public contract, subsystem, or material scope expansion, return the evidence to Workflow.
-
-## Refactor Locally
-
-Refactor only when it improves the behavior just implemented while its focused check remains green.
-
-TDD refactoring is immediate local cleanup within the behavior loop. It may improve names, remove nearby duplication, simplify control flow, or clarify ownership without changing the accepted result.
-
-Do not turn REFACTOR into a general cleanup stream. When reducing existing complexity is itself an accepted result, return the completed behavior loop and use [Simplify Code](../simplify-code/SKILL.md) as a separate execution route.
-
-When test pressure exposes caller coordination, public states, test-only seams, or ownership problems, preserve that evidence. Use [Design for Depth](../design-for-depth/SKILL.md) only when structural pressure is supported.
-
-## Fix Bugs Through The Reported Boundary
-
-First reproduce the reported symptom through the correct seam. A nearby failing path is diagnostic evidence, not the bug.
-
-After GREEN, rerun:
-
-1. the minimized regression check;
-2. the original unminimized symptom or strongest available observer;
-3. the smallest affected boundary capable of exposing regression.
-
-Do not report a fix when only the minimized check passes and the reported boundary remains unavailable.
-
-## Return The Method Result
-
-Return to the current owner with:
-
-- accepted behavior and observing seam;
-- observed RED result and why it was valid;
-- GREEN implementation result;
-- local refactor, when performed;
-- focused, original-path, and affected-boundary evidence;
-- what the evidence supports and does not support;
-- unresolved or unverified behavior.
-
-Do not select another behavior, close the Slice, trigger review, commit, or continue merely because GREEN was reached.