@hassangameryt/freeflow 0.7.3 → 0.9.0

package/hooks/tests/check-runtime-context-hook.sh

@@ -1,212 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(CDPATH='' cd -- "$(dirname -- "$0")/../.." && pwd)"
-HOOK_PATH="$ROOT_DIR/hooks/freeflow-runtime-context.mjs"
-CLAUDE_HOOKS_JSON="$ROOT_DIR/hooks/claude/hooks.json"
-CODEX_HOOKS_JSON="$ROOT_DIR/hooks/codex/hooks.json"
-GEMINI_HOOKS_JSON="$ROOT_DIR/hooks/hooks.json"
-CURSOR_HOOKS_JSON="$ROOT_DIR/hooks/cursor/hooks.json"
-COPILOT_HOOKS_JSON="$ROOT_DIR/com.github.copilot/hooks/hooks.json"
-CORE_PROMPT="$ROOT_DIR/runtime/prompts/core.md"
-INTERACTION_PROMPT="$ROOT_DIR/runtime/prompts/interaction-contract.md"
-
-fail() {
-  echo "runtime-context hook check failed: $*" >&2
-  exit 1
-}
-
-assert_contains() {
-  local text="$1"
-  local expected="$2"
-  local label="$3"
-  grep -Fq -- "$expected" <<<"$text" || fail "$label missing '$expected'"
-}
-
-assert_not_contains() {
-  local text="$1"
-  local unexpected="$2"
-  local label="$3"
-  if grep -Fq -- "$unexpected" <<<"$text"; then
-    fail "$label unexpectedly contains '$unexpected'"
-  fi
-}
-
-[[ -f "$HOOK_PATH" ]] || fail "missing hook script"
-for hooks_manifest in "$CLAUDE_HOOKS_JSON" "$CODEX_HOOKS_JSON" "$GEMINI_HOOKS_JSON" "$CURSOR_HOOKS_JSON" "$COPILOT_HOOKS_JSON"; do
-  [[ -f "$hooks_manifest" ]] || fail "missing hooks manifest: $hooks_manifest"
-done
-[[ -f "$CORE_PROMPT" ]] || fail "missing core prompt"
-[[ -f "$INTERACTION_PROMPT" ]] || fail "missing interaction contract prompt"
-[[ ! -f "$ROOT_DIR/runtime/prompts/skills.md" ]] || fail "retired skills prompt remains"
-node --check "$HOOK_PATH"
-node -e '
-const fs = require("fs");
-const hooks = JSON.parse(fs.readFileSync(process.argv[1], "utf8")).hooks || {};
-if (!Array.isArray(hooks.SessionStart) || hooks.SessionStart.length !== 1) process.exit(1);
-if (hooks.SessionStart[0]?.matcher !== "startup|resume|clear|compact") process.exit(1);
-if (hooks.UserPromptSubmit || hooks.SessionEnd) process.exit(1);
-' "$CODEX_HOOKS_JSON" || fail "Codex hooks manifest does not expose only SessionStart"
-node -e '
-const fs = require("fs");
-const hooks = JSON.parse(fs.readFileSync(process.argv[1], "utf8")).hooks || {};
-if (!Array.isArray(hooks.SessionStart) || hooks.SessionStart.length !== 1) process.exit(1);
-if (hooks.SessionStart[0]?.matcher !== "startup|resume|clear|compact") process.exit(1);
-' "$CLAUDE_HOOKS_JSON" || fail "Claude hooks manifest does not preserve lifecycle starts"
-node -e '
-const fs = require("fs");
-const hooks = JSON.parse(fs.readFileSync(process.argv[1], "utf8")).hooks || {};
-if (!Array.isArray(hooks.SessionStart) || hooks.SessionStart.length !== 1) process.exit(1);
-if (Object.prototype.hasOwnProperty.call(hooks.SessionStart[0], "matcher")) process.exit(1);
-' "$GEMINI_HOOKS_JSON" || fail "Gemini hooks manifest does not expose SessionStart"
-node -e '
-const fs = require("fs");
-const hooks = JSON.parse(fs.readFileSync(process.argv[1], "utf8")).hooks || {};
-if (!Array.isArray(hooks.sessionStart) || hooks.sessionStart.length !== 1) process.exit(1);
-' "$CURSOR_HOOKS_JSON" || fail "Cursor hooks manifest does not expose sessionStart"
-node -e '
-const fs = require("fs");
-const config = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
-if (config.version !== 1 || !Array.isArray(config.hooks?.SessionStart) || config.hooks.SessionStart.length !== 1) process.exit(1);
-' "$COPILOT_HOOKS_JSON" || fail "Copilot hooks manifest does not expose versioned SessionStart"
-
-tmp_dir="$(mktemp -d)"
-trap 'rm -rf "$tmp_dir"' EXIT
-mkdir -p "$tmp_dir/.freeflow"
-printf '{}\n' >"$tmp_dir/.freeflow/config.json"
-
-codex_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$tmp_dir" | node "$HOOK_PATH" SessionStart)"
-disabled_by_env="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$tmp_dir" | FREEFLOW_DISABLE_RUNTIME_CONTEXT=1 node "$HOOK_PATH" SessionStart)"
-[[ -z "$disabled_by_env" ]] || fail "FREEFLOW_DISABLE_RUNTIME_CONTEXT=1 should suppress injection"
-
-for unsupported_event in PostToolUse UserPromptSubmit SessionEnd; do
-  unsupported_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$tmp_dir" | node "$HOOK_PATH" "$unsupported_event")"
-  [[ -z "$unsupported_output" ]] || fail "$unsupported_event should not inject runtime context"
-done
-
-for expected in \
-  '"hookEventName":"SessionStart"' \
-  "# Freeflow Stable Guidance" \
-  "## Shared Terms" \
-  "## Recover After Context Loss" \
-  "## Three Nested Loops" \
-  "## Workflow Cue" \
-  "## Action Selection Cue" \
-  "## Supported Exit" \
-  "# Freeflow Interaction Contract" \
-  "Questions, criticism, examples, hypotheses, and tentative ideas do not authorize action by themselves." \
-  "Freeflow: active"; do
-  assert_contains "$codex_output" "$expected" "configured core context"
-done
-assert_not_contains "$codex_output" "## Mode" "configured core context"
-assert_not_contains "$codex_output" "Default mode" "configured core context"
-assert_not_contains "$codex_output" "Active mode" "configured core context"
-assert_not_contains "$codex_output" "Interaction Contract: enabled" "configured core context"
-assert_not_contains "$codex_output" "Skills: enabled" "configured core context"
-assert_not_contains "$codex_output" "session-modes" "configured core context"
-
-# Empty mandatory fragments fail closed rather than emitting a partial active surface.
-whitespace_root="$(mktemp -d)"
-mkdir -p "$whitespace_root/hooks" "$whitespace_root/runtime/prompts" "$whitespace_root/repo/.freeflow"
-cp "$HOOK_PATH" "$whitespace_root/hooks/freeflow-runtime-context.mjs"
-mkdir -p "$whitespace_root/hooks/adapters" "$whitespace_root/hooks/shared"
-cp "$ROOT_DIR/hooks/adapters/codex-session-start.mjs" "$whitespace_root/hooks/adapters/codex-session-start.mjs"
-cp "$ROOT_DIR/hooks/shared/runtime-context.mjs" "$whitespace_root/hooks/shared/runtime-context.mjs"
-cp -R "$ROOT_DIR/runtime/prompts/." "$whitespace_root/runtime/prompts/"
-printf ' \n\t\n' >"$whitespace_root/runtime/prompts/core.md"
-printf '{}\n' >"$whitespace_root/repo/.freeflow/config.json"
-whitespace_output="$(printf '{\"cwd\":\"%s\"}\n' "$whitespace_root/repo" | node "$whitespace_root/hooks/freeflow-runtime-context.mjs" SessionStart)"
-[[ -z "$whitespace_output" ]] || fail "whitespace-only mandatory prompt should fail closed"
-rm -rf "$whitespace_root"
-
-claude_output="$(printf '{"hook_event_name":"SessionStart","source":"startup","cwd":"%s"}\n' "$tmp_dir" | node "$HOOK_PATH" SessionStart)"
-assert_contains "$claude_output" '"hookEventName":"SessionStart"' "Claude wrapper"
-assert_contains "$claude_output" "# Freeflow Interaction Contract" "Claude core context"
-assert_contains "$claude_output" "## Shared Terms" "Claude core context"
-assert_contains "$claude_output" "Freeflow: active" "Claude core context"
-
-# Every supported lifecycle start receives the same mandatory core surface.
-for source in startup resume clear compact; do
-  output="$(printf '{"hook_event_name":"SessionStart","source":"%s","cwd":"%s"}\n' "$source" "$tmp_dir" | node "$HOOK_PATH" SessionStart)"
-  assert_contains "$output" "# Freeflow Stable Guidance" "$source SessionStart context"
-  assert_contains "$output" "# Freeflow Interaction Contract" "$source SessionStart context"
-  assert_contains "$output" "Freeflow: active" "$source SessionStart context"
-done
-
-# Pi-only configuration remains isolated from the shared non-Pi hook.
-cognitive_dir="$(mktemp -d)"
-mkdir -p "$cognitive_dir/.freeflow"
-printf '{"cognitiveRouting":{"enabled":true}}\n' >"$cognitive_dir/.freeflow/config.json"
-cognitive_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$cognitive_dir" | node "$HOOK_PATH" SessionStart)"
-assert_contains "$cognitive_output" "# Freeflow Stable Guidance" "Pi-only capability tolerance"
-assert_not_contains "$cognitive_output" "Cognitive Routing" "non-Pi capability isolation"
-rm -rf "$cognitive_dir"
-
-# Old mode and core-toggle configuration is a breaking invalidation, not a compatibility path.
-for obsolete_config in \
-  '{"defaultMode":"workflow"}' \
-  '{"interactionContract":false}' \
-  '{"skills":{"enabled":false}}'; do
-  obsolete_dir="$(mktemp -d)"
-  mkdir -p "$obsolete_dir/.freeflow"
-  printf '%s\n' "$obsolete_config" >"$obsolete_dir/.freeflow/config.json"
-  obsolete_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$obsolete_dir" | node "$HOOK_PATH" SessionStart)"
-  [[ -z "$obsolete_output" ]] || fail "obsolete config should not activate: $obsolete_config"
-  rm -rf "$obsolete_dir"
-done
-
-# No prompt-submit or clear-transfer path may create or consume legacy session state.
-state_dir="$(mktemp -d)"
-printf '{"hook_event_name":"UserPromptSubmit","session_id":"old-session","cwd":"%s","prompt":"Switch to conversation mode."}\n' "$tmp_dir" |
-  PLUGIN_DATA="$state_dir" node "$HOOK_PATH" UserPromptSubmit >/dev/null
-printf '{"hook_event_name":"SessionEnd","reason":"clear","session_id":"old-session","cwd":"%s"}\n' "$tmp_dir" |
-  PLUGIN_DATA="$state_dir" node "$HOOK_PATH" SessionEnd >/dev/null
-[[ ! -e "$state_dir/session-modes" ]] || fail "legacy session-mode state directory was created"
-rm -rf "$state_dir"
-
-# Missing, invalid, disabled, and invalid-local activation remain inert.
-missing_dir="$(mktemp -d)"
-invalid_dir="$(mktemp -d)"
-mkdir -p "$invalid_dir/.freeflow"
-printf '{invalid\n' >"$invalid_dir/.freeflow/config.json"
-missing_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$missing_dir" | node "$HOOK_PATH" SessionStart)"
-invalid_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$invalid_dir" | node "$HOOK_PATH" SessionStart)"
-[[ -z "$missing_output" ]] || fail "missing config should not activate runtime context"
-[[ -z "$invalid_output" ]] || fail "invalid config should not activate runtime context"
-rm -rf "$missing_dir" "$invalid_dir"
-
-disabled_dir="$(mktemp -d)"
-mkdir -p "$disabled_dir/.freeflow"
-printf '{"enabled":false}\n' >"$disabled_dir/.freeflow/config.json"
-disabled_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$disabled_dir" | node "$HOOK_PATH" SessionStart)"
-[[ -z "$disabled_output" ]] || fail "disabled Freeflow should suppress hook prompt delivery"
-rm -rf "$disabled_dir"
-
-invalid_local_dir="$(mktemp -d)"
-mkdir -p "$invalid_local_dir/.freeflow"
-printf '{}\n' >"$invalid_local_dir/.freeflow/config.json"
-printf '{"enabled":"no"}\n' >"$invalid_local_dir/.freeflow/local.json"
-invalid_local_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$invalid_local_dir" | node "$HOOK_PATH" SessionStart)"
-[[ -z "$invalid_local_output" ]] || fail "invalid local config should fail closed"
-rm -rf "$invalid_local_dir"
-
-# Personal disablement remains separate from shared activation.
-local_disabled_dir="$(mktemp -d)"
-mkdir -p "$local_disabled_dir/.freeflow"
-printf '{}\n' >"$local_disabled_dir/.freeflow/config.json"
-printf '{"enabled":false}\n' >"$local_disabled_dir/.freeflow/local.json"
-local_disabled_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$local_disabled_dir" | node "$HOOK_PATH" SessionStart)"
-[[ -z "$local_disabled_output" ]] || fail "local master override should suppress hook prompt delivery"
-rm -rf "$local_disabled_dir"
-
-# Repo-owned host instructions are not activation markers and are not modified.
-printf '# Repo agents\n\nKeep this guidance.\n' >"$tmp_dir/AGENTS.md"
-printf '# Repo Claude\n\nKeep this guidance too.\n' >"$tmp_dir/CLAUDE.md"
-cp "$tmp_dir/AGENTS.md" "$tmp_dir/AGENTS.before"
-cp "$tmp_dir/CLAUDE.md" "$tmp_dir/CLAUDE.before"
-host_output="$(printf '{"cwd":"%s","model":"gpt-5"}\n' "$tmp_dir" | node "$HOOK_PATH" SessionStart)"
-assert_contains "$host_output" "# Freeflow Interaction Contract" "host-independent activation"
-cmp -s "$tmp_dir/AGENTS.before" "$tmp_dir/AGENTS.md" || fail "hook modified AGENTS.md"
-cmp -s "$tmp_dir/CLAUDE.before" "$tmp_dir/CLAUDE.md" || fail "hook modified CLAUDE.md"
-
-echo "runtime-context hook checks passed"

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

@@ -1,330 +0,0 @@
-import { annotateSources } from "../session-sources/provenance.js";
-import { randomUUID } from "node:crypto";
-import { textRef } from "../session-sources/sources.js";
-import { canonical, emptySelection, isWorkerProfile, requireCondition as check } from "./types.js";
-import { estimateRequest } from "./budget.js";
-export function changeSelection(prior, input, sources, state) {
-  check(
-    Array.isArray(input.refs) &&
-      input.refs.length <= 64 &&
-      input.refs.every((r) => typeof r === "string" && r.length <= 512),
-    "invalid_refs",
-  );
-  if (input.operation === "remove")
-    check(
-      typeof input.reason === "string" && input.reason.trim() && input.reason.length <= 2048,
-      "withdrawal_reason_required",
-    );
-  const next = structuredClone(prior);
-  for (const ref of new Set(input.refs)) {
-    const existed = next.selected.includes(ref) || next.unresolved.some((p) => p.ref === ref);
-    if (input.operation === "remove") {
-      next.unresolved = next.unresolved.filter((p) => p.ref !== ref);
-      next.selected = next.selected.filter((r) => r !== ref);
-      if (existed) next.withdrawals.push({ ref, reason: input.reason });
-      continue;
-    }
-    const problem = prior.selected.includes(ref) ? sources.eligible(ref, state) : sources.selectionProblem(ref, state);
-    const index = next.unresolved.findIndex((p) => p.ref === ref);
-    if (problem) {
-      if (index < 0) next.unresolved.push(problem);
-      else next.unresolved[index] = problem;
-    } else {
-      if (index >= 0) next.unresolved.splice(index, 1);
-      if (!next.selected.includes(ref)) next.selected.push(ref);
-    }
-  }
-  if (canonical(next) === canonical(prior)) return prior;
-  next.revision++;
-  return next;
-}
-export function representationProblems(source, model, structural = false) {
-  const message = source.original?.message ?? source.message,
-    content = Array.isArray(source.message.content) ? source.message.content : [];
-  if (message.role === "assistant" && ["error", "aborted"].includes(message.stopReason))
-    return [
-      {
-        ref: source.ref,
-        code: "target_representation",
-        detail:
-          "Native compatibility conversion may omit failed/aborted assistant output; exact delivery is not promised.",
-      },
-    ];
-  if (content.some((b) => b.type === "image") && !model?.input?.includes("image"))
-    return [
-      { ref: source.ref, code: "target_representation", detail: "The receiving model does not support image input." },
-    ];
-  if (
-    !structural &&
-    !source.original &&
-    content.some((b) => b.type === "thinking" && (b.redacted || b.thinkingSignature)) &&
-    (message.provider !== model?.provider || message.model !== model?.id || message.api !== model?.api)
-  )
-    return [
-      {
-        ref: source.ref,
-        code: "target_representation",
-        detail: `Whole native signed content is not qualified across this model boundary. Inspect the explicit assistant-text source ${textRef(source.ref)} when visible text is the intended evidence.`,
-      },
-    ];
-  return [];
-}
-export function prepareView(options) {
-  const { sources, state } = options;
-  const associated = sources.associate(options.messages);
-  const selective = options.projection && options.view === "coordinator";
-  const assessment = state.assessment;
-  const attention = selective && assessment?.view === "suspended" && !options.restoring && !options.preparingReturn;
-  const handoffId = options.preparingReturn ?? (!attention ? assessment?.handoffId : undefined);
-  const handoff = handoffId ? state.handoffs.get(handoffId) : undefined;
-  const assignmentId = handoff?.assignmentId ?? state.assignmentId;
-  const current = assignmentId ? (state.selections.get(assignmentId) ?? emptySelection()) : emptySelection();
-  const required = new Set(selective && !attention && assignmentId ? current.selected : []);
-  const promised = handoff && state.reservations.get(handoff.id);
-  const admitted = new Set();
-  if (selective)
-    for (const selection of state.selections.values()) for (const ref of selection.selected) admitted.add(ref);
-  // Accepted return receipts are communication, independent of selected task evidence.
-  // Their ordinary active occurrence survives closure; compaction still owns its lifetime.
-  const full = new Map();
-  const structural = new Map();
-  const problems = selective && !attention && assignmentId ? [...current.unresolved] : [];
-  for (const item of associated) {
-    if (!item.source) continue;
-    if (
-      !selective ||
-      !isWorkerProfile(item.source.producer) ||
-      admitted.has(item.source.ref) ||
-      (item.source.reportHandoff && state.handoffs.has(item.source.reportHandoff))
-    )
-      full.set(item.source.ref, item.source);
-    const visible = sources.byRef.get(textRef(item.source.ref));
-    if (selective && visible && admitted.has(visible.ref)) full.set(visible.ref, visible);
-  }
-  for (const ref of required) {
-    if (sources.ambiguous.has(ref)) {
-      problems.push({
-        ref,
-        code: "ambiguous_occurrence",
-        detail: "The active representation cannot be associated with one canonical occurrence.",
-      });
-      continue;
-    }
-    const source = sources.byRef.get(ref),
-      error = sources.eligible(ref, state);
-    if (error) {
-      problems.push(error);
-      continue;
-    }
-    const expected =
-      promised && promised.selectionRevision === current.revision
-        ? promised.sources.find((s) => s.ref === ref)
-        : undefined;
-    if (expected && expected.bodyHash !== source.hash) {
-      problems.push({
-        ref,
-        code: "source_changed",
-        detail: "The captured source differs from the prepared reservation.",
-      });
-      continue;
-    }
-    full.set(ref, source);
-  }
-  // A selected result carries its complete native call group; siblings may be structural only.
-  for (const source of full.values()) {
-    const exchange = sources.exchange(source);
-    if (required.has(source.ref)) problems.push(...exchange.problems, ...representationProblems(source, options.model));
-    for (const sibling of exchange.sources) if (!full.has(sibling.ref)) structural.set(sibling.ref, sibling);
-  }
-  for (const source of structural.values())
-    if (source.message.role === "assistant" && required.size)
-      problems.push(...representationProblems(source, options.model, true));
-  const render = (source) => {
-    const message = structuredClone(source.message);
-    if (source.message.role === "assistant" && !full.has(source.ref) && full.has(textRef(source.ref)))
-      message.content = message.content.filter((b) => b.type !== "text");
-    if (full.has(source.ref) || source.message.role !== "toolResult") return message;
-    return {
-      ...structuredClone(source.message),
-      content: [{ type: "text", text: "[Worker result omitted from this view]" }],
-      details: undefined,
-    };
-  };
-  // Insert resolved historical occurrences before the first later native occurrence, retaining
-  // opaque/common messages in their original order rather than moving user input wholesale.
-  const ordered = sources.ordered(new Map([...structural, ...full]).values());
-  const rank = new Map(options.sources.entries.map((entry, index) => [entry.id, index]));
-  const activeRefs = new Set(associated.flatMap((i) => (i.source ? [i.source.ref] : [])));
-  const historical = ordered.filter((s) => !activeRefs.has(s.ref));
-  const emitted = new Set();
-  let messages = [];
-  const renderedSources = new Map();
-  let cursor = 0;
-  const emit = (source) => {
-    if (source.original && full.has(source.original.ref)) return;
-    if (!emitted.has(source.ref)) {
-      const message = render(source);
-      messages.push(message);
-      renderedSources.set(message, source);
-      emitted.add(source.ref);
-    }
-  };
-  for (const item of associated) {
-    if (item.source) {
-      while (
-        cursor < historical.length &&
-        (rank.get(historical[cursor].entry.id) ?? 0) < (rank.get(item.source.entry.id) ?? 0)
-      )
-        emit(historical[cursor++]);
-      const visible = full.get(textRef(item.source.ref));
-      if (visible) emit(visible);
-      if (full.has(item.source.ref) || structural.has(item.source.ref)) emit(item.source);
-    } else messages.push(item.message);
-  }
-  while (cursor < historical.length) emit(historical[cursor++]);
-  const fullSources = [...full.values()];
-  messages = annotateSources(messages, renderedSources, new Set(full.keys()), sources, options.instance);
-  // Restore exact current communication only when its accepted occurrence is absent.
-  const a = state.assignmentId ? state.assignments.get(state.assignmentId) : undefined;
-  const baseReport = assessment
-    ? state.handoffs.get(assessment.handoffId)
-    : handoff?.kind === "return"
-      ? handoff
-      : undefined;
-  const recovery = state.recoveryId
-    ? state.recoveries.get(state.recoveryId)
-    : [...state.recoveries.values()]
-        .reverse()
-        .find(
-          (candidate) => candidate.assessmentHandoffId === assessment?.handoffId && candidate.state === "completed",
-        );
-  const recoveryRequest = recovery ? state.handoffs.get(recovery.requestHandoffId) : undefined;
-  const supplement =
-    handoff?.kind === "recovery-return"
-      ? handoff
-      : recovery?.supplementHandoffId
-        ? state.handoffs.get(recovery.supplementHandoffId)
-        : undefined;
-  const hasCommunication = (h, field, value, metadata = {}) =>
-    messages.some((m) => {
-      const matches = (payload) =>
-        payload?.[field] === value &&
-        Object.entries(metadata).every(([key, expected]) => canonical(payload?.[key]) === canonical(expected));
-      if (m.role === "assistant")
-        return m.content?.some((b) => b.type === "toolCall" && b.id === h.toolCallId && matches(b.arguments));
-      if (m.role !== "toolResult" || m.toolCallId !== h.toolCallId) return false;
-      return m.content?.some((b) => {
-        if (b.type !== "text") return false;
-        try {
-          return matches(JSON.parse(b.text));
-        } catch {
-          return false;
-        }
-      });
-    });
-  const restore = (kind, id, body) =>
-    messages.push({
-      role: "custom",
-      customType: "freeflow-routing-communication",
-      display: false,
-      content: `${kind} ${id}:\n${body}`,
-      timestamp: 0,
-      details: { routingInstance: options.instance },
-    });
-  if (a) {
-    const accepted = state.handoffs.get(a.delegateHandoffId);
-    if (accepted && !hasCommunication(accepted, "contract", a.contract))
-      restore("Current exact assignment", a.id, a.contract);
-  }
-  if (baseReport) {
-    const metadata = { outcome: baseReport.outcome, limitations: baseReport.limitations };
-    const hasBody = hasCommunication(baseReport, "report", baseReport.text);
-    // Tool arguments establish accepted content but do not carry harness-assigned
-    // revision/lineage. Old receipts and partially retained calls need metadata too.
-    const complete = hasCommunication(baseReport, "report", baseReport.text, {
-      ...metadata,
-      reportRevision: baseReport.reportRevision,
-      assignmentRef: `assignment:${baseReport.assignmentId}`,
-      reportRef: `report:${baseReport.id}:${baseReport.reportRevision}`,
-    });
-    if (!complete)
-      restore(
-        "Saved report",
-        baseReport.id,
-        `Producer: ${baseReport.from}\nAssignment: assignment:${baseReport.assignmentId}\nReport ref: report:${baseReport.id}:${baseReport.reportRevision}\nRevision: ${baseReport.reportRevision}\nOutcome: ${baseReport.outcome}\nLimitations: ${JSON.stringify(baseReport.limitations)}${hasBody ? "\nReport text is present in its accepted native occurrence above." : `\nReport:\n${baseReport.text}`}`,
-      );
-  }
-  if (recovery && recoveryRequest && !hasCommunication(recoveryRequest, "request", recovery.request))
-    restore(
-      "Recovery request",
-      recovery.id,
-      `Assignment: assignment:${recovery.assignmentId}\nParent report: report:${recovery.assessmentHandoffId}:${recovery.baseReportRevision}\nAllowed paths: ${JSON.stringify(recovery.paths)}\nRequest:\n${recovery.request}`,
-    );
-  if (recovery && supplement) {
-    const hasBody = hasCommunication(supplement, "report", supplement.text);
-    const complete = hasCommunication(supplement, "report", supplement.text, {
-      outcome: supplement.outcome,
-      limitations: supplement.limitations,
-    });
-    if (!complete)
-      restore(
-        "Recovery supplement",
-        recovery.id,
-        `Assignment: assignment:${recovery.assignmentId}\nParent report: report:${recovery.assessmentHandoffId}:${recovery.baseReportRevision}\nSupplement revision: ${supplement.reportRevision}\nOutcome: ${supplement.outcome}\nLimitations: ${JSON.stringify(supplement.limitations)}${hasBody ? "\nSupplement text is present in its accepted native occurrence above." : `\nSupplement:\n${supplement.text}`}`,
-      );
-  }
-  messages.push(options.runtimeMessage);
-  const { estimatedTokens, maximumInputTokens, outputReserve, estimateMethod, warnings } = estimateRequest(
-    options.systemPrompt,
-    options.tools,
-    messages,
-    options.model,
-  );
-  if (warnings.length)
-    messages.push({
-      role: "custom",
-      customType: "freeflow-routing-budget",
-      display: false,
-      content: warnings.map((w) => w.detail).join("\n"),
-      timestamp: 0,
-      details: { routingInstance: options.instance },
-    });
-  if (!options.model?.contextWindow)
-    problems.push({ ref: "", code: "delivery_budget", detail: "Receiving model context capacity is unavailable." });
-  const reservation =
-    handoff && selective
-      ? {
-          id: randomUUID(),
-          selectionRevision: current.revision,
-          receiver: "coordinator",
-          target: options.pair,
-          qualification: `native-structural:${options.model?.api ?? "unknown"}; serialized receipt unobserved`,
-          sources: [...required].flatMap((ref) => {
-            const source = sources.byRef.get(ref);
-            return source ? [{ ref, bodyHash: source.hash }] : [];
-          }),
-          maximumInputTokens,
-          outputReserve,
-          estimateMethod,
-        }
-      : undefined;
-  return {
-    warnings,
-    ready: problems.length === 0,
-    // Recorded usage describes a prior provider view, which may belong to the
-    // other profile. Pi must estimate this assembled view when allocating output.
-    // Normalize request metadata only; canonical usage/billing records stay intact.
-    messages: messages.map((message) => ({
-      ...message,
-      timestamp: Number.isFinite(message.timestamp) ? message.timestamp : 0,
-      ...(message.role === "assistant"
-        ? { usage: { ...message.usage, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 } }
-        : {}),
-    })),
-    problems,
-    fullSources,
-    reservation,
-    estimatedTokens,
-    estimateMethod,
-  };
-}