@hassangameryt/freeflow 0.5.0 → 0.7.0

package/pi-extension/dist/cognitive-routing/pi-session-control.js

@@ -0,0 +1,320 @@
+export const PI_SESSION_MODEL_STATE_ENTRY = "freeflow-cognitive-routing-model-state";
+export function supportsPiSessionModelStateApi(pi) {
+  if (!pi || typeof pi !== "object") return false;
+  const candidate = pi;
+  return (
+    typeof candidate.appendEntry === "function" &&
+    typeof candidate.setModel === "function" &&
+    typeof candidate.setThinkingLevel === "function"
+  );
+}
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isThinkingLevel(value) {
+  return typeof value === "string" && THINKING_LEVELS.has(value);
+}
+function appendModelStateCommit(pi, commit) {
+  try {
+    pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, commit);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pairFrom(value) {
+  if (!isRecord(value)) return undefined;
+  if (
+    typeof value.provider !== "string" ||
+    typeof value.modelId !== "string" ||
+    !isThinkingLevel(value.thinkingLevel)
+  ) {
+    return undefined;
+  }
+  return {
+    provider: value.provider,
+    modelId: value.modelId,
+    thinkingLevel: value.thinkingLevel,
+  };
+}
+function failureFrom(value) {
+  if (
+    value === "model-change-failed" ||
+    value === "thinking-level-change-failed" ||
+    value === "pair-verification-failed" ||
+    value === "rollback-failed" ||
+    value === "commit-persistence-failed" ||
+    value === "interrupted-transition"
+  ) {
+    return value;
+  }
+  return undefined;
+}
+function originFrom(value) {
+  if (!isRecord(value)) return undefined;
+  if (value.source !== "pi" || value.operation !== "session-model-state-control") return undefined;
+  return { source: "pi", operation: "session-model-state-control" };
+}
+export function parsePiSessionModelStateCommit(value) {
+  if (!isRecord(value) || value.version !== 1) return undefined;
+  if (value.phase !== "prepared" && value.phase !== "committed" && value.phase !== "aborted") return undefined;
+  if (
+    value.status !== "prepared" &&
+    value.status !== "applied" &&
+    value.status !== "rolled-back" &&
+    value.status !== "rollback-failed"
+  ) {
+    return undefined;
+  }
+  if (typeof value.correlationId !== "string") return undefined;
+  const fromPair = pairFrom(value.fromPair);
+  const target = pairFrom(value.target);
+  const origin = originFrom(value.origin);
+  if (!fromPair || !target || !origin) return undefined;
+  if (value.phase === "prepared" && value.status !== "prepared") return undefined;
+  if (value.phase === "committed" && value.status !== "applied") return undefined;
+  if (value.phase === "aborted" && (value.status === "prepared" || value.status === "applied")) return undefined;
+  const failure = failureFrom(value.failure);
+  if ((value.phase === "prepared" || value.phase === "committed") && value.failure !== undefined) return undefined;
+  if (value.phase === "aborted" && !failure) return undefined;
+  let observedPair;
+  if (value.observedPair !== undefined) {
+    observedPair = pairFrom(value.observedPair);
+    if (!observedPair) return undefined;
+  }
+  return {
+    version: 1,
+    phase: value.phase,
+    status: value.status,
+    correlationId: value.correlationId,
+    fromPair,
+    target,
+    ...(failure ? { failure } : {}),
+    ...(observedPair ? { observedPair } : {}),
+    origin,
+  };
+}
+function currentPair(ctx) {
+  const model = ctx.model;
+  if (!model || typeof model.provider !== "string" || typeof model.id !== "string") return undefined;
+  if (!ctx.thinkingLevel) return undefined;
+  return {
+    provider: model.provider,
+    modelId: model.id,
+    thinkingLevel: ctx.thinkingLevel,
+  };
+}
+function pairsEqual(left, right) {
+  return (
+    left?.provider === right.provider && left.modelId === right.modelId && left.thinkingLevel === right.thinkingLevel
+  );
+}
+async function restorePair(pi, ctx, pair) {
+  const model = ctx.modelRegistry?.find(pair.provider, pair.modelId);
+  if (!model) return false;
+  try {
+    if (!(await pi.setModel(model))) return false;
+    pi.setThinkingLevel(pair.thinkingLevel);
+    return pairsEqual(currentPair(ctx), pair);
+  } catch {
+    return false;
+  }
+}
+export function createPiSessionControllerHost({ pi, ctx }) {
+  const control = createPiSessionModelStateControl({ pi, ctx });
+  return {
+    appendEntryDurable(customType, data) {
+      pi.appendEntry(customType, data);
+    },
+    acquireModelStateControl: control.acquireModelStateControl,
+    recoverPreparedModelState: control.recoverPreparedModelState,
+  };
+}
+export function createPiSessionModelStateControl({ pi, ctx }) {
+  let owner;
+  return {
+    async recoverPreparedModelState({ fromPair, target, correlationId }) {
+      const current = currentPair(ctx);
+      if (!current || !pairsEqual(current, fromPair)) {
+        if (!(await restorePair(pi, ctx, fromPair))) {
+          const rollbackFailed = {
+            version: 1,
+            phase: "aborted",
+            status: "rollback-failed",
+            correlationId,
+            fromPair,
+            target,
+            failure: "rollback-failed",
+            ...(currentPair(ctx) ? { observedPair: currentPair(ctx) } : {}),
+            origin: { source: "pi", operation: "session-model-state-control" },
+          };
+          try {
+            pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, rollbackFailed);
+          } catch {
+            return { status: "rejected" };
+          }
+          return { status: "rollback-failed" };
+        }
+      }
+      const aborted = {
+        version: 1,
+        phase: "aborted",
+        status: "rolled-back",
+        correlationId,
+        fromPair,
+        target,
+        failure: "interrupted-transition",
+        origin: { source: "pi", operation: "session-model-state-control" },
+      };
+      try {
+        pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, aborted);
+      } catch {
+        return { status: "rejected" };
+      }
+      return { status: "restored" };
+    },
+    async acquireModelStateControl({ label }) {
+      if (owner !== undefined) return { status: "conflict", owner };
+      owner = label;
+      let released = false;
+      return {
+        status: "acquired",
+        lease: {
+          async setState(request) {
+            if (released) return { status: "rejected" };
+            const fromPair = currentPair(ctx);
+            const targetModel = ctx.modelRegistry?.find(request.provider, request.modelId);
+            if (!fromPair || !targetModel) return { status: "rejected" };
+            const target = {
+              provider: request.provider,
+              modelId: request.modelId,
+              thinkingLevel: request.thinkingLevel,
+            };
+            const prepared = {
+              version: 1,
+              phase: "prepared",
+              status: "prepared",
+              correlationId: request.correlationId,
+              fromPair,
+              target,
+              origin: { source: "pi", operation: "session-model-state-control" },
+            };
+            try {
+              pi.appendEntry(PI_SESSION_MODEL_STATE_ENTRY, prepared);
+            } catch {
+              return { status: "rejected" };
+            }
+            let failure;
+            try {
+              const applied = await pi.setModel(targetModel);
+              if (!applied) {
+                const aborted = {
+                  version: 1,
+                  phase: "aborted",
+                  status: "rolled-back",
+                  correlationId: request.correlationId,
+                  fromPair,
+                  target,
+                  failure: "model-change-failed",
+                  origin: { source: "pi", operation: "session-model-state-control" },
+                };
+                appendModelStateCommit(pi, aborted);
+                return { status: "rejected" };
+              }
+              try {
+                pi.setThinkingLevel(request.thinkingLevel);
+              } catch {
+                failure = "thinking-level-change-failed";
+              }
+              if (!failure && !pairsEqual(currentPair(ctx), target)) {
+                failure = "pair-verification-failed";
+              }
+            } catch {
+              failure = "model-change-failed";
+            }
+            if (failure) {
+              const restored = await restorePair(pi, ctx, fromPair);
+              if (!restored) {
+                const rollbackFailed = {
+                  version: 1,
+                  phase: "aborted",
+                  status: "rollback-failed",
+                  correlationId: request.correlationId,
+                  fromPair,
+                  target,
+                  failure: "rollback-failed",
+                  ...(currentPair(ctx) ? { observedPair: currentPair(ctx) } : {}),
+                  origin: { source: "pi", operation: "session-model-state-control" },
+                };
+                appendModelStateCommit(pi, rollbackFailed);
+                return { status: "rejected" };
+              }
+              const aborted = {
+                version: 1,
+                phase: "aborted",
+                status: "rolled-back",
+                correlationId: request.correlationId,
+                fromPair,
+                target,
+                failure,
+                origin: { source: "pi", operation: "session-model-state-control" },
+              };
+              appendModelStateCommit(pi, aborted);
+              return { status: "rejected" };
+            }
+            const commit = {
+              version: 1,
+              phase: "committed",
+              status: "applied",
+              correlationId: request.correlationId,
+              fromPair,
+              target,
+              origin: { source: "pi", operation: "session-model-state-control" },
+            };
+            try {
+              if (!appendModelStateCommit(pi, commit)) throw new Error("commit persistence failed");
+              return { status: "applied" };
+            } catch {
+              const restored = await restorePair(pi, ctx, fromPair);
+              if (!restored) {
+                const rollbackFailed = {
+                  version: 1,
+                  phase: "aborted",
+                  status: "rollback-failed",
+                  correlationId: request.correlationId,
+                  fromPair,
+                  target,
+                  failure: "rollback-failed",
+                  ...(currentPair(ctx) ? { observedPair: currentPair(ctx) } : {}),
+                  origin: { source: "pi", operation: "session-model-state-control" },
+                };
+                appendModelStateCommit(pi, rollbackFailed);
+                return { status: "rejected" };
+              }
+              const aborted = {
+                version: 1,
+                phase: "aborted",
+                status: "rolled-back",
+                correlationId: request.correlationId,
+                fromPair,
+                target,
+                failure: "commit-persistence-failed",
+                origin: { source: "pi", operation: "session-model-state-control" },
+              };
+              appendModelStateCommit(pi, aborted);
+              return { status: "rejected" };
+            }
+          },
+          async release() {
+            if (!released) {
+              released = true;
+              if (owner === label) owner = undefined;
+            }
+            return { status: "released" };
+          },
+        },
+      };
+    },
+  };
+}

package/pi-extension/dist/cognitive-routing/runtime.js

@@ -0,0 +1,43 @@
+import { resolveCognitiveRoutingConfig } from "./config.js";
+import { preflightCognitiveRoutingProfiles } from "./host.js";
+function blockingReason(code, message) {
+  return { code, message };
+}
+function baseState(config) {
+  return {
+    configured: config.configured,
+    configValid: config.valid,
+    enabled: config.enabled,
+    effective: false,
+    enabledSource: config.enabledSource,
+    profiles: config.profiles,
+    profileSources: config.profileSources,
+    sessionStart: config.sessionStart,
+    sessionStartSources: config.sessionStartSources,
+    resolvedProfiles: {},
+    blockingReason: blockingReason("disabled", "Cognitive Routing is disabled"),
+  };
+}
+export async function resolveCognitiveRoutingState(repositoryConfig, personalConfig, host) {
+  const config = resolveCognitiveRoutingConfig(repositoryConfig, personalConfig);
+  const state = baseState(config);
+  if (!config.valid) {
+    return {
+      ...state,
+      blockingReason: blockingReason(
+        "config_invalid",
+        config.error?.message ?? "Cognitive Routing configuration is invalid",
+      ),
+    };
+  }
+  if (!config.enabled) {
+    return state;
+  }
+  const preflight = await preflightCognitiveRoutingProfiles(config, host);
+  return {
+    ...state,
+    effective: preflight.effective,
+    resolvedProfiles: preflight.resolvedProfiles,
+    blockingReason: preflight.blockingReason ?? blockingReason("disabled", "Cognitive Routing is not effective"),
+  };
+}

package/pi-extension/dist/cognitive-routing/tool.js

@@ -0,0 +1,212 @@
+import { textComponent } from "../ui/text-component.js";
+export const COGNITIVE_ROUTING_SWITCH_TOOL_NAME = "freeflow_switch_profile";
+export const COGNITIVE_ROUTING_HISTORY_TOOL_NAME = "freeflow_cognitive_routing_history";
+export const COGNITIVE_ROUTING_HISTORY_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    scope: {
+      type: "string",
+      enum: ["session", "active-branch"],
+      description: "History scope to read.",
+    },
+    anomaliesOnly: {
+      type: "boolean",
+      description: "Return only events whose integrity is anomaly.",
+    },
+    limit: {
+      type: "integer",
+      minimum: 1,
+      maximum: 100,
+      description: "Maximum number of newest events to return.",
+    },
+  },
+  required: [],
+};
+export const COGNITIVE_ROUTING_SWITCH_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    target: {
+      type: "string",
+      enum: ["standard", "reasoning"],
+      description: "The configured Cognitive Routing profile to activate.",
+    },
+    reason: {
+      type: "string",
+      minLength: 1,
+      maxLength: 160,
+      description: "A concise one-line reason for the profile transition.",
+    },
+  },
+  required: ["target", "reason"],
+};
+function resultText(result) {
+  if (result.status === "active") {
+    const fields = [COGNITIVE_ROUTING_SWITCH_TOOL_NAME + "|active", `profile|${result.profile}`];
+    if (result.changed !== undefined) fields.push(`changed|${result.changed}`);
+    if (result.from) fields.push(`from|${result.from}`);
+    if (result.to) fields.push(`to|${result.to}`);
+    return fields.join("\n");
+  }
+  return `${COGNITIVE_ROUTING_SWITCH_TOOL_NAME}|${result.status}\nreason|${result.reason}`;
+}
+function blocked(reason) {
+  return { status: "blocked", reason };
+}
+function renderNothing() {
+  return {
+    render() {
+      return [];
+    },
+    invalidate() {},
+  };
+}
+function renderTransition(text, theme) {
+  return textComponent(theme?.fg ? theme.fg("accent", text) : text);
+}
+function isProfileName(value) {
+  return value === "standard" || value === "reasoning";
+}
+function resultFromPayload(payload) {
+  const details = payload?.details?.result ?? payload?.result ?? payload?.details;
+  if (details && (details.status === "active" || details.status === "blocked" || details.status === "inactive")) {
+    if (details.status !== "active") return details;
+    if (!isProfileName(details.profile)) return undefined;
+    return {
+      status: "active",
+      profile: details.profile,
+      ...(typeof details.changed === "boolean" ? { changed: details.changed } : {}),
+      ...(isProfileName(details.from) ? { from: details.from } : {}),
+      ...(isProfileName(details.to) ? { to: details.to } : {}),
+    };
+  }
+  const text = Array.isArray(payload?.content)
+    ? payload.content.find((part) => part?.type === "text")?.text
+    : undefined;
+  if (typeof text !== "string") return undefined;
+  const fields = new Map();
+  for (const line of text.split("\\n")) {
+    const separator = line.indexOf("|");
+    if (separator <= 0) continue;
+    fields.set(line.slice(0, separator), line.slice(separator + 1));
+  }
+  const status = fields.get(COGNITIVE_ROUTING_SWITCH_TOOL_NAME);
+  if (status === "active") {
+    const profile = fields.get("profile");
+    if (!isProfileName(profile)) return undefined;
+    const changed = fields.get("changed");
+    const from = fields.get("from");
+    const to = fields.get("to");
+    return {
+      status,
+      profile,
+      ...(changed === "true" || changed === "false" ? { changed: changed === "true" } : {}),
+      ...(isProfileName(from) ? { from } : {}),
+      ...(isProfileName(to) ? { to } : {}),
+    };
+  }
+  if (status === "blocked" || status === "inactive") {
+    const reason = fields.get("reason");
+    return reason ? { status, reason } : undefined;
+  }
+  return undefined;
+}
+function historyOptions(params) {
+  return {
+    ...(params.scope === "active-branch" ? { scope: "active-branch" } : {}),
+    ...(params.anomaliesOnly === true ? { anomaliesOnly: true } : {}),
+    ...(Number.isInteger(params.limit) ? { limit: Math.max(1, Math.min(100, params.limit)) } : {}),
+  };
+}
+function validateParams(params) {
+  if (params.target !== "standard" && params.target !== "reasoning") {
+    return { status: "invalid", reason: "target_must_be_standard_or_reasoning" };
+  }
+  if (typeof params.reason !== "string") {
+    return { status: "invalid", reason: "reason_required" };
+  }
+  const reason = params.reason.trim();
+  if (!reason) return { status: "invalid", reason: "reason_required" };
+  if (reason.includes("\n") || reason.includes("\r"))
+    return { status: "invalid", reason: "reason_must_be_single_line" };
+  if (reason.length > 160) return { status: "invalid", reason: "reason_too_long" };
+  return { status: "valid", target: params.target, reason };
+}
+export function registerCognitiveRoutingTool(pi, getController) {
+  pi.registerTool({
+    name: COGNITIVE_ROUTING_SWITCH_TOOL_NAME,
+    label: "Switch Cognitive Profile",
+    description: "Request one bounded Cognitive Routing profile transition while automatic control is active.",
+    promptSnippet: "Switch between the configured standard and reasoning profiles when the current task needs it.",
+    promptGuidelines: [
+      "Use only when the current task needs a different reasoning profile.",
+      "Give one concise sentence as the reason and make this the only tool call in the response.",
+      "Do not call this tool while a deterministic manual profile hold is active.",
+    ],
+    parameters: COGNITIVE_ROUTING_SWITCH_PARAMETERS,
+    executionMode: "sequential",
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const controller = getController();
+      const input = validateParams(params ?? {});
+      let result;
+      if (input.status === "invalid") {
+        result = blocked(input.reason);
+      } else if (!controller) {
+        result = blocked("not_available");
+      } else if (!controller.state().effective) {
+        result = blocked("not_active");
+      } else if (controller.state().controlMode === "automatic") {
+        result = await controller.switchAutomaticProfile(input.target, input.reason);
+      } else {
+        result = blocked("manual_hold");
+      }
+      return {
+        content: [{ type: "text", text: resultText(result) }],
+        details: { result },
+      };
+    },
+    renderCall(_args, _theme) {
+      return renderNothing();
+    },
+    renderResult(result, _options, theme) {
+      const outcome = resultFromPayload(result);
+      if (outcome?.status === "active") {
+        if (outcome.changed === true && outcome.from && outcome.to) {
+          return renderTransition(`Cognitive Routing: ${outcome.from} → ${outcome.to}`, theme);
+        }
+        if (outcome.changed === false && outcome.to) {
+          return renderTransition(`Cognitive Routing: ${outcome.to} (already active)`, theme);
+        }
+        return renderTransition(`Cognitive Routing: active · ${outcome.profile}`, theme);
+      }
+      if (outcome) {
+        return renderTransition(`Cognitive Routing: ${outcome.status} · ${outcome.reason}`, theme);
+      }
+      return renderTransition(`Cognitive Routing: ${result?.isError ? "error" : "result unavailable"}`, theme);
+    },
+  });
+}
+export function registerCognitiveRoutingHistoryTool(pi, readHistory) {
+  pi.registerTool({
+    name: COGNITIVE_ROUTING_HISTORY_TOOL_NAME,
+    label: "Read Cognitive Routing History",
+    description:
+      "Read the deterministic Cognitive Routing transition history without changing routing or session state.",
+    promptSnippet: "Inspect Cognitive Routing transition history when debugging or monitoring profile behavior.",
+    promptGuidelines: [
+      "Use only when debugging or monitoring Cognitive Routing is requested.",
+      "This tool is read-only and does not change profile, control, branch, or session state.",
+      "Use scope=active-branch to inspect only the current branch ancestry.",
+      "Use anomaliesOnly=true to inspect only integrity anomalies.",
+    ],
+    parameters: COGNITIVE_ROUTING_HISTORY_PARAMETERS,
+    async execute(_toolCallId, params, _signal, _onUpdate, context) {
+      const result = await readHistory(historyOptions(params ?? {}), context);
+      return {
+        content: [{ type: "text", text: `Cognitive Routing history\n${JSON.stringify(result)}` }],
+        details: { result },
+      };
+    },
+  });
+}

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

@@ -0,0 +1,6 @@
+export const COGNITIVE_ROUTING_PROFILE_NAMES = ["standard", "reasoning"];
+export const COGNITIVE_ROUTING_SESSION_START_CONTROLS = ["automatic", "manual"];
+export const DEFAULT_COGNITIVE_ROUTING_SESSION_START = {
+  control: "automatic",
+  profile: "reasoning",
+};

package/pi-extension/dist/context-virtualization/commands.js

@@ -0,0 +1,89 @@
+function formatStatus(status, features) {
+  if (!status.available) {
+    return `Freeflow Context: unavailable${status.unavailableReason ? ` (${status.unavailableReason})` : ""}`;
+  }
+  return [
+    "Freeflow Context: available",
+    `Context Virtualization: ${features.contextVirtualization ? "enabled" : "disabled"}`,
+    `Conversation History: ${features.conversationHistory ? "enabled" : "disabled"}`,
+    `Session: ${status.sessionId}`,
+    `Branch: ${status.branchLeafId ?? "root"}`,
+    `Projections: full=${status.counts.full}, archived=${status.counts.archived}, retained=${status.counts.retained}`,
+    `Characters: original=${status.originalCharacters.toLocaleString("en-US")}, projected=${status.projectedCharacters.toLocaleString("en-US")}`,
+    `Availability: history-only=${status.historyOnly}, unresolved=${status.unresolved}`,
+  ].join("\n");
+}
+function formatList(status) {
+  if (!status.available) return formatStatus(status, { contextVirtualization: true, conversationHistory: false });
+  const items = status.items.filter((item) => item.mode === "archived");
+  if (items.length === 0) return "Context Virtualization: no archived projections in the active session branch.";
+  const lines = ["Context Virtualization: archived projections"];
+  for (const item of items) {
+    lines.push(
+      "",
+      `Ref: ${item.ref}`,
+      `Tool: ${item.toolName ?? "tool"}`,
+      `State: ${item.retained === undefined ? "archived" : "retained"}`,
+      `Original: ${item.originalCharacters.toLocaleString("en-US")} characters`,
+      `Projected: ${item.projectedCharacters.toLocaleString("en-US")} characters`,
+      `Availability: ${item.availability}`,
+    );
+    if (item.retained !== undefined) lines.push(`Retained: ${item.retained}`);
+  }
+  return lines.join("\n");
+}
+function refsFromArgs(args) {
+  return args
+    .split(/[\s,]+/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+export async function handleContextCommand(args, ctx, runtime, enabled, conversationHistoryEnabled = false) {
+  const input = (args ?? "status").trim();
+  const [action = "status", ...rest] = input.split(/\s+/);
+  const normalized = action.toLowerCase();
+  if (!runtime) {
+    ctx.ui.notify("Context Virtualization is unavailable for this session.", "warning");
+    return { changed: false, error: "unavailable" };
+  }
+  if (normalized === "status") {
+    const status = await runtime.status();
+    ctx.ui.notify(
+      formatStatus(status, { contextVirtualization: enabled, conversationHistory: conversationHistoryEnabled }),
+      enabled || conversationHistoryEnabled ? "info" : "warning",
+    );
+    return { changed: false, status };
+  }
+  if (normalized === "list") {
+    const status = await runtime.status();
+    ctx.ui.notify(formatList(status), enabled ? "info" : "warning");
+    return { changed: false, status };
+  }
+  if (normalized === "restore") {
+    const refs = refsFromArgs(rest.join(" "));
+    if (!enabled) {
+      ctx.ui.notify("Context Virtualization is disabled by configuration; no projection state was changed.", "warning");
+      return { changed: false, error: "disabled" };
+    }
+    const result = await runtime.restore(refs, "user");
+    ctx.ui.notify(
+      result.message ?? `${result.status}: ${result.operation}`,
+      result.status === "ok" ? "info" : "warning",
+    );
+    return { changed: result.status === "ok", result };
+  }
+  if (normalized === "reset" && rest.join(" ").toLowerCase() === "all") {
+    if (!enabled) {
+      ctx.ui.notify("Context Virtualization is disabled by configuration; no projection state was changed.", "warning");
+      return { changed: false, error: "disabled" };
+    }
+    const result = await runtime.reset();
+    ctx.ui.notify(
+      result.message ?? `${result.status}: ${result.operation}`,
+      result.status === "ok" ? "info" : "warning",
+    );
+    return { changed: result.status === "ok", result };
+  }
+  ctx.ui.notify("Usage: /freeflow context [status|list|restore <ctx:entryId>...|reset all]", "warning");
+  return { changed: false, error: "invalid_action" };
+}