@hassangameryt/freeflow 0.7.1 → 0.7.2

package/pi-extension/dist/cognitive-routing-v2/tools.js

@@ -0,0 +1,91 @@
+import { ROUTING_TOOLS } from "./runtime.js";
+import { ROUTING_SCHEMAS, matches, schemaForProfile } from "./schemas.js";
+export { ROUTING_SCHEMAS } from "./schemas.js";
+import { renderRoutingCall, renderRoutingResult } from "./render.js";
+const descriptions = {
+  freeflow_delegate:
+    "Save a supported assignment contract and request Executor execution. Explicit replace supersedes a quiescent outstanding assignment in the same unit.",
+  freeflow_return:
+    "Save or revise the actual assignment report, or retry its saved handoff without resubmitting text. Returning does not accept or close the unit.",
+  freeflow_unit:
+    "Inspect current responsibility, paginated work history, or exact saved contract/report details. Coordinator can also restore a suspended assessment or close a unit without clearing its history.",
+  freeflow_project:
+    "Inspect current selection and scoped candidates, then add or remove completed exposed Executor sources. #text refs select exact visible assistant text; plain refs retain whole-native meaning. Eligibility and target readiness are distinct.",
+};
+const guidance = {
+  freeflow_delegate: [
+    "freeflow_delegate is Coordinator-only under Automatic control. Put the contract in the input. Use replace only for explicit same-unit replacement; do not supply IDs.",
+  ],
+  freeflow_return: [
+    "freeflow_return submit saves/revises the actual report; retry completes the saved return without text. Stop ordinary task work after reportSaved. Keep the handoff last; do not batch it with new task tools.",
+  ],
+  freeflow_unit: [
+    "freeflow_unit inspect defaults to current state; view history returns work refs and view detail with ref reads saved contracts/reports. Coordinator assess restores a suspended evidence obligation; close changes work status without clearing communication or completing a Working Record task.",
+  ],
+  freeflow_project: [
+    "freeflow_project inspect shows selection and scoped candidates. Use history scope for earlier exposed evidence. #text refs select exact visible assistant text; plain refs retain whole-native meaning. Select actual result bodies for execution claims, not merely calls. Correct or explicitly withdraw unresolved items with a limitation. Known previously exposed bodies resolve automatically; target-representation gaps are not successful delivery.",
+  ],
+};
+const unitDefinitions = new WeakMap();
+export function registerRoutingTools(pi, runtime) {
+  for (const name of ROUTING_TOOLS) {
+    const definition = {
+      name,
+      label: name.replace("freeflow_", "Routing "),
+      description: descriptions[name],
+      parameters: ROUTING_SCHEMAS[name],
+      executionMode: "sequential",
+      promptGuidelines: guidance[name],
+      renderCall: (args, _theme, context) => renderRoutingCall(name, args, context),
+      renderResult: (result, options, _theme, context) => renderRoutingResult(result, options, name, context),
+      async execute(id, input, signal, _update, ctx) {
+        if (!matches(input, ROUTING_SCHEMAS[name]))
+          throw new Error("Invalid routing arguments; no operation accepted.");
+        return runtime.invoke(name, id, input, signal, ctx);
+      },
+    };
+    pi.registerTool(definition);
+    if (name === "freeflow_unit") unitDefinitions.set(pi, { definition });
+  }
+}
+export function applyRoutingToolVisibility(pi, runtime, available) {
+  if (!pi.getActiveTools || !pi.setActiveTools) return;
+  const current = new Set(pi.getActiveTools());
+  const state = runtime.state();
+  const unit = unitDefinitions.get(pi);
+  const coordinator = state.effective && state.controlMode === "automatic" && state.activeProfile === "coordinator";
+  const signature = coordinator ? "coordinator" : "inspection";
+  if (unit && unit.signature !== signature) {
+    pi.registerTool({
+      ...unit.definition,
+      description: coordinator
+        ? unit.definition.description
+        : "Inspect current routing responsibility, work history, or exact saved contract/report detail. This profile cannot assess or close units.",
+      promptGuidelines: coordinator
+        ? unit.definition.promptGuidelines
+        : [
+            "freeflow_unit inspect reads current state, view history lists work refs, and view detail with ref reads historical communication. Historical content is not current permission.",
+          ],
+      parameters: schemaForProfile("freeflow_unit", coordinator),
+    });
+    unit.signature = signature;
+  }
+  for (const name of ROUTING_TOOLS) {
+    const enabled =
+      available &&
+      (name === "freeflow_unit" ||
+        (state.effective &&
+          state.controlMode === "automatic" &&
+          (name === "freeflow_delegate"
+            ? state.activeProfile === "coordinator"
+            : state.activeProfile === "executor"))) &&
+      (name !== "freeflow_project" || runtime.projectionEnabled);
+    if (enabled) current.add(name);
+    else current.delete(name);
+  }
+  // Retired experimental tools must never remain available beside the replacement.
+  current.delete("freeflow_switch_profile");
+  current.delete("freeflow_cognitive_routing_history");
+  const next = [...current];
+  if (JSON.stringify(next) !== JSON.stringify(pi.getActiveTools())) pi.setActiveTools(next);
+}

package/pi-extension/dist/cognitive-routing-v2/types.js

@@ -0,0 +1,44 @@
+export const ROUTING_ENTRY = "freeflow-routing-v2";
+export const ROUTING_MESSAGE = "freeflow-routing-v2-state";
+export const PROFILES = ["coordinator", "executor"];
+export const EFFORTS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export class RoutingError extends Error {
+  code;
+  problems;
+  constructor(code, message, problems = []) {
+    super(message);
+    this.code = code;
+    this.problems = problems;
+    this.name = "RoutingError";
+  }
+}
+export function fail(code, message) {
+  throw new RoutingError(code, message);
+}
+export function requireCondition(condition, code, message = code) {
+  if (!condition) fail(code, message);
+}
+export function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isObject(value))
+    return `{${Object.keys(value)
+      .filter((k) => value[k] !== undefined)
+      .sort()
+      .map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`)
+      .join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+}
+export function samePair(left, right) {
+  return !!left && !!right && canonical(left) === canonical(right);
+}
+export const eventKey = (event) => JSON.stringify([event.operationId, event.data.type, event.stepId]);
+export const eventValue = (event) =>
+  canonical({ version: event.version, operationId: event.operationId, stepId: event.stepId, data: event.data });
+export const emptySelection = () => ({ revision: 0, selected: [], unresolved: [], withdrawals: [] });
+export const refFor = (id) => `ctx:${id}`;
+export function idFor(ref) {
+  return /^ctx:([^\s:#]+)(?:#text)?$/.exec(ref)?.[1];
+}

package/pi-extension/dist/freeflow-context/tool.js

@@ -93,6 +93,11 @@ function contextParameters(features) {
       operationSchema(CONVERSATION_HISTORY_RETRIEVE_PROPERTIES, ["operation", "refs"]),
     );
   }
+  if (oneOf.length === 0) {
+    // Codex rejects an empty oneOf even when the tool is inactive. Keep the
+    // placeholder schema valid until capability-specific operations are enabled.
+    return { type: "object", additionalProperties: false, properties: {} };
+  }
   return { type: "object", oneOf };
 }
 function resultText(result) {