@hassangameryt/freeflow 0.4.0 → 0.6.0

package/hooks/freeflow-runtime-context.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
@@ -8,6 +9,9 @@ import { fileURLToPath } from "node:url";
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PLUGIN_ROOT = path.resolve(SCRIPT_DIR, "..");
 const VALID_MODES = new Set(["conversation", "workflow", "strict-workflow"]);
+const SESSION_STATE_VERSION = 1;
+const SESSION_STATE_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+const CLEAR_TRANSFER_MAX_AGE_MS = 60 * 1000;
 
 function readStdinJson() {
   const raw = fs.readFileSync(0, "utf8").trim();
@@ -49,24 +53,17 @@ function findWorkspaceRoot(cwd) {
 function loadRuntimeContext(options = {}) {
   const includeInteractionContract = options.interactionContract === true;
   const includeSkills = options.skills === true;
-  const includeOutputRouter = options.outputRouter === true;
+  const corePrompt = readText(path.join(PLUGIN_ROOT, "runtime", "prompts", "core.md"));
   const interactionContract = includeInteractionContract
-    ? readText(path.join(PLUGIN_ROOT, "runtime", "interaction-contract.md"))
-    : null;
-  const workflowSkill = includeSkills ? readText(path.join(PLUGIN_ROOT, "skills", "workflow", "SKILL.md")) : null;
-  const outputRouterSkill = includeOutputRouter
-    ? readText(path.join(PLUGIN_ROOT, "skills", "output-router", "SKILL.md"))
+    ? readText(path.join(PLUGIN_ROOT, "runtime", "prompts", "interaction-contract.md"))
     : null;
+  const skillsPrompt = includeSkills ? readText(path.join(PLUGIN_ROOT, "runtime", "prompts", "skills.md")) : null;
 
-  if (
-    (includeInteractionContract && !interactionContract) ||
-    (includeSkills && !workflowSkill) ||
-    (includeOutputRouter && !outputRouterSkill)
-  ) {
-    throw new Error("Freeflow runtime context files are missing.");
+  if (!corePrompt || (includeInteractionContract && !interactionContract) || (includeSkills && !skillsPrompt)) {
+    throw new Error("Freeflow runtime prompt files are missing.");
   }
 
-  return { interactionContract, workflowSkill, outputRouterSkill };
+  return { corePrompt, interactionContract, skillsPrompt };
 }
 
 function readConfig(root) {
@@ -76,7 +73,6 @@ function readConfig(root) {
   const configured = repository.valid && localValid;
   const core = resolveCoreConfig(repository.valid ? repository.parsed : {}, local.valid ? local.parsed : {});
   const enabled = configured && core.config.enabled;
-  const repositoryConfig = repository.valid ? repository.parsed : {};
 
   return {
     exists: repository.exists,
@@ -85,13 +81,12 @@ function readConfig(root) {
     repositoryValid: repository.valid,
     localExists: local.exists,
     localValid,
-    error: !repository.valid ? repository.error : local.error,
+    error: repository.valid ? local.error : repository.error,
     enabled,
     interactionContractEnabled: enabled && core.config.interactionContract,
     skillsEnabled: enabled && core.config.skills.enabled,
     defaultMode: core.config.defaultMode,
     sources: core.sources,
-    outputRouterEnabled: enabled && repositoryConfig?.outputRouter?.enabled === true,
   };
 }
 
@@ -126,23 +121,20 @@ function isRecord(value) {
 }
 
 function validateCoreConfigFields(value) {
-  if (Object.prototype.hasOwnProperty.call(value, "defaultMode") && !VALID_MODES.has(value.defaultMode)) {
+  if (Object.hasOwn(value, "defaultMode") && !VALID_MODES.has(value.defaultMode)) {
     return "defaultMode must be conversation, workflow, or strict-workflow";
   }
-  if (Object.prototype.hasOwnProperty.call(value, "enabled") && typeof value.enabled !== "boolean") {
+  if (Object.hasOwn(value, "enabled") && typeof value.enabled !== "boolean") {
     return "enabled must be a boolean";
   }
-  if (
-    Object.prototype.hasOwnProperty.call(value, "interactionContract") &&
-    typeof value.interactionContract !== "boolean"
-  ) {
+  if (Object.hasOwn(value, "interactionContract") && typeof value.interactionContract !== "boolean") {
     return "interactionContract must be a boolean";
   }
-  if (Object.prototype.hasOwnProperty.call(value, "skills")) {
+  if (Object.hasOwn(value, "skills")) {
     if (!isRecord(value.skills)) {
       return "skills must be an object";
     }
-    if (Object.prototype.hasOwnProperty.call(value.skills, "enabled") && typeof value.skills.enabled !== "boolean") {
+    if (Object.hasOwn(value.skills, "enabled") && typeof value.skills.enabled !== "boolean") {
       return "skills.enabled must be a boolean";
     }
   }
@@ -162,6 +154,7 @@ function isValidSetupConfig(value) {
     "outputRouter",
     "observedRouting",
     "scriptTransform",
+    "cognitiveRouting",
   ]);
   if (!Object.keys(value).every((key) => allowedKeys.has(key))) {
     return "repository config contains unsupported top-level keys";
@@ -173,7 +166,7 @@ function isValidSetupConfig(value) {
   }
 
   for (const key of ["outputRouter", "observedRouting", "scriptTransform"]) {
-    if (Object.prototype.hasOwnProperty.call(value, key) && !isRecord(value[key])) {
+    if (Object.hasOwn(value, key) && !isRecord(value[key])) {
       return `${key} must be an object`;
     }
   }
@@ -185,7 +178,14 @@ function isValidLocalConfig(value) {
     return "local config must be a JSON object";
   }
 
-  const allowedKeys = new Set(["enabled", "defaultMode", "interactionContract", "skills", "processing"]);
+  const allowedKeys = new Set([
+    "enabled",
+    "defaultMode",
+    "interactionContract",
+    "skills",
+    "processing",
+    "cognitiveRouting",
+  ]);
   if (!Object.keys(value).every((key) => allowedKeys.has(key))) {
     return "local config contains unsupported top-level keys";
   }
@@ -193,7 +193,7 @@ function isValidLocalConfig(value) {
 }
 
 function hasOwn(value, key) {
-  return Object.prototype.hasOwnProperty.call(value, key);
+  return Object.hasOwn(value, key);
 }
 
 function resolveLayeredValue(repository, local, key, fallback) {
@@ -230,159 +230,391 @@ function resolveCoreConfig(repository, local) {
   };
 }
 
-function inspectSetup(root) {
-  return { config: readConfig(root) };
+function hostName() {
+  return process.env.PLUGIN_DATA ? "codex" : "claude";
 }
 
-function configStatus(config) {
-  if (!config.valid) {
-    return "invalid layered configuration";
-  }
-  const source = config.sources.defaultMode;
-  const personal = config.localExists ? "; personal overrides present" : "";
-  return `defaultMode \`${config.defaultMode}\` from ${source}${personal}`;
-}
-
-function modeOverlayGuidance(mode) {
-  if (mode === "conversation") {
-    return [
-      "",
-      "## Conversation Mode Boundary",
-      "",
-      "Conversation mode is active and read-only.",
-      "",
-      "Do not call write, edit, or mutating tools. Do not create, delete, commit, push, or change repository, system, external, or durable state.",
-      "",
-      "A mutation request does not switch mode, and an execution skill does not override this boundary. Explain that conversation mode is read-only and ask the user to switch to workflow or strict-workflow.",
-    ];
-  }
-
-  if (mode === "strict-workflow") {
-    return [
-      "",
-      "## Strict Workflow Overlay",
-      "",
-      "Strict Workflow is active. Use the adaptive Workflow, but increase decision, evidence, verification, and checkpoint pressure at high-risk or hard-to-reverse boundaries.",
-      "",
-      "For work affecting security, privacy, billing, data loss, migrations, public interfaces, compatibility, deployment, or architecture:",
-      "",
-      "- stop for any user-owned choice or source conflict;",
-      "- inspect the relevant risk surface before crossing the boundary;",
-      "- select only artifacts, checkpoints, and independent review that materially reduce risk;",
-      "- verify at the affected boundary before claiming success.",
-      "",
-      "Do not manufacture ceremony for low-risk, reversible work. Strict Workflow does not authorize mutation, bypass safety, or make every implementation detail a user decision.",
-    ];
-  }
-
-  return [];
-}
-
-function modeGuidance(mode) {
-  return [
-    `Current Freeflow default mode: \`${mode}\`.`,
-    "Treat this as the resolved default at session start, resume, clear, and compact.",
-    "Mode behavior:",
-    "- `conversation`: answer, discuss, critique, and inspect read-only; switch modes before mutating state.",
-    "- `workflow`: use the adaptive workflow for normal consequential work.",
-    "- `strict-workflow`: strengthen user-owned decisions, review, and verification for high-risk or hard-to-reverse work.",
-    "Do not announce the current mode on every reply. Mention it when the user asks, setup/config is discussed, or the mode changes the next action.",
-    ...modeOverlayGuidance(mode),
-  ];
+function pluginDataRoot() {
+  const configured = process.env.PLUGIN_DATA || process.env.CLAUDE_PLUGIN_DATA;
+  return configured ? path.resolve(configured) : null;
 }
 
-function buildSetupStatus(root) {
-  const { config } = inspectSetup(root);
-  if (!config.valid) {
-    return "Setup status: Freeflow is not configured for this repo.";
+function sessionStatePath(sessionId) {
+  const dataRoot = pluginDataRoot();
+  if (!dataRoot || typeof sessionId !== "string" || sessionId.length === 0) {
+    return null;
   }
 
-  const modeStatus = config.skillsEnabled
-    ? modeGuidance(config.defaultMode)
-    : [`Resolved default mode: \`${config.defaultMode}\` (dormant because Skills are disabled).`];
-  return [
-    `Setup status: configured by \`.freeflow/config.json\` with ${configStatus(config)}.`,
-    "Runtime delivery: confirmed for this lifecycle-hook invocation.",
-    ...modeStatus,
-  ].join("\n");
+  const key = crypto.createHash("sha256").update(`${hostName()}\0${sessionId}`).digest("hex");
+  return path.join(dataRoot, "session-modes", hostName(), `${key}.json`);
 }
 
-function shouldInject(eventName) {
-  if (process.env.FREEFLOW_DISABLE_RUNTIME_CONTEXT === "1") {
+function workspaceKey(root) {
+  return crypto.createHash("sha256").update(path.resolve(root)).digest("hex");
+}
+
+function claudeProcessKey() {
+  const processId = process.env.CLAUDE_PID;
+  if (typeof processId !== "string" || processId.length === 0) {
+    return null;
+  }
+  return crypto.createHash("sha256").update(processId).digest("hex");
+}
+
+function clearTransferPath(root) {
+  const dataRoot = pluginDataRoot();
+  const processKey = claudeProcessKey();
+  if (!dataRoot || hostName() !== "claude" || !processKey) {
+    return null;
+  }
+  return path.join(dataRoot, "session-modes", "claude-clear", `${workspaceKey(root)}-${processKey}.json`);
+}
+
+function writeJsonAtomic(filePath, value) {
+  const directory = path.dirname(filePath);
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const temporaryPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporaryPath, `${JSON.stringify(value)}\n`, { encoding: "utf8", mode: 0o600 });
+    fs.renameSync(temporaryPath, filePath);
+  } catch (error) {
+    try {
+      fs.unlinkSync(temporaryPath);
+    } catch {
+      // Best-effort cleanup of a failed atomic write.
+    }
+    throw error;
+  }
+}
+
+function readSessionMode(sessionId) {
+  const filePath = sessionStatePath(sessionId);
+  if (!filePath) {
+    return null;
+  }
+
+  try {
+    const state = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (state.version !== SESSION_STATE_VERSION || !VALID_MODES.has(state.mode)) {
+      return null;
+    }
+    return state.mode;
+  } catch {
+    return null;
+  }
+}
+
+function writeSessionMode(sessionId, mode) {
+  const filePath = sessionStatePath(sessionId);
+  if (!filePath) {
     return false;
   }
 
-  return eventName === "SessionStart";
+  writeJsonAtomic(filePath, {
+    version: SESSION_STATE_VERSION,
+    mode,
+    updatedAt: new Date().toISOString(),
+  });
+  return true;
+}
+
+function clearSessionMode(sessionId) {
+  const filePath = sessionStatePath(sessionId);
+  if (!filePath) {
+    return false;
+  }
+
+  try {
+    fs.unlinkSync(filePath);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return true;
+}
+
+function stageClearTransfer(input) {
+  if (hostName() !== "claude" || input.reason !== "clear") {
+    return;
+  }
+
+  const root = findWorkspaceRoot(input.cwd || process.cwd());
+  const mode = readSessionMode(input.session_id);
+  const filePath = clearTransferPath(root);
+  if (!filePath) {
+    return;
+  }
+
+  if (!mode) {
+    try {
+      fs.unlinkSync(filePath);
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    return;
+  }
+
+  writeJsonAtomic(filePath, {
+    version: SESSION_STATE_VERSION,
+    mode,
+    sourceSessionKey: crypto.createHash("sha256").update(String(input.session_id)).digest("hex"),
+    createdAt: new Date().toISOString(),
+  });
+}
+
+function consumeClearTransfer(input, root) {
+  if (hostName() !== "claude" || input.source !== "clear") {
+    return null;
+  }
+
+  const filePath = clearTransferPath(root);
+  if (!filePath) {
+    return null;
+  }
+
+  const claimedPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.claimed`;
+  try {
+    fs.renameSync(filePath, claimedPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return null;
+    }
+    return null;
+  }
+
+  let state;
+  try {
+    state = JSON.parse(fs.readFileSync(claimedPath, "utf8"));
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs.unlinkSync(claimedPath);
+    } catch {
+      // The atomic claim already prevents reuse; cleanup is best-effort.
+    }
+  }
+
+  if (!isRecord(state)) {
+    return null;
+  }
+  const createdAt = Date.parse(state.createdAt);
+  if (
+    state.version !== SESSION_STATE_VERSION ||
+    !VALID_MODES.has(state.mode) ||
+    !Number.isFinite(createdAt) ||
+    Date.now() - createdAt > CLEAR_TRANSFER_MAX_AGE_MS ||
+    Date.now() < createdAt
+  ) {
+    return null;
+  }
+
+  return writeSessionMode(input.session_id, state.mode) ? state.mode : null;
+}
+
+function cleanupExpiredSessionModes() {
+  const root = pluginDataRoot();
+  if (!root) {
+    return;
+  }
+
+  const stateRoot = path.join(root, "session-modes");
+  const cutoff = Date.now() - SESSION_STATE_MAX_AGE_MS;
+  for (const host of ["claude", "codex", "claude-clear"]) {
+    const directory = path.join(stateRoot, host);
+    let entries = [];
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) {
+        continue;
+      }
+      const filePath = path.join(directory, entry.name);
+      try {
+        if (fs.statSync(filePath).mtimeMs < cutoff) {
+          fs.unlinkSync(filePath);
+        }
+      } catch {
+        // Cleanup is best-effort and must not prevent runtime delivery.
+      }
+    }
+  }
+}
+
+function sourceLabel(source) {
+  if (source === "local") {
+    return "personal";
+  }
+  return source;
 }
 
-function capabilityStatus(config) {
+function resolveRuntimeState(input) {
+  const root = findWorkspaceRoot(input.cwd || process.cwd());
+  const config = readConfig(root);
+  const restoredMode = config.valid && config.enabled ? consumeClearTransfer(input, root) : null;
+  const sessionMode = config.valid && config.enabled ? restoredMode || readSessionMode(input.session_id) : null;
+  const resolvedMode = sessionMode || config.defaultMode;
+
+  return {
+    root,
+    config,
+    sessionMode,
+    resolvedMode,
+    effectiveMode: config.enabled && config.skillsEnabled ? resolvedMode : null,
+    modeSource: sessionMode ? "session override" : "configured default",
+  };
+}
+
+function stateLines(state, sessionChange = null) {
+  const { config } = state;
+  const lines = [`Configured default: \`${config.defaultMode}\` (${sourceLabel(config.sources.defaultMode)})`];
+
+  if (sessionChange === "cleared") {
+    lines.push("Session override: cleared");
+  } else if (state.sessionMode) {
+    lines.push(`Session override: \`${state.sessionMode}\``);
+  } else {
+    lines.push("Session override: none");
+  }
+
+  if (state.effectiveMode) {
+    lines.push(`Effective mode: \`${state.effectiveMode}\` (${state.modeSource}, active)`);
+  } else {
+    lines.push(`Resolved mode: \`${state.resolvedMode}\` (dormant because Skills are disabled)`);
+  }
+
+  return lines;
+}
+
+function capabilityLines(config) {
   return [
-    "## Freeflow Capabilities",
-    "",
-    `- Interaction Contract: ${config.interactionContractEnabled ? "enabled" : "disabled"}.`,
-    `- Skills: ${config.skillsEnabled ? "enabled" : "disabled"}.`,
-    `- Output router: ${config.outputRouterEnabled ? "enabled" : "disabled"}.`,
-    "",
-    "Capability-specific instructions are active only while that capability is enabled.",
+    `Interaction Contract: ${config.interactionContractEnabled ? "enabled" : "disabled"}`,
+    `Skills: ${config.skillsEnabled ? "enabled" : "disabled"}`,
   ];
 }
 
-function buildContext(input) {
-  const root = findWorkspaceRoot(input.cwd || process.cwd());
-  const setup = inspectSetup(root);
+function runtimeStateContext(state, sessionChange = null) {
+  const { config } = state;
+  return ["# Freeflow Runtime State", "", ...stateLines(state, sessionChange), "", ...capabilityLines(config)].join(
+    "\n",
+  );
+}
 
-  if (!setup.config.valid) {
+function renderSessionStart(state) {
+  const { config } = state;
+  if (!config.valid) {
     return "";
   }
 
-  if (!setup.config.enabled) {
-    return [
-      "# Freeflow Disabled",
-      "",
-      `Freeflow is configured for this repo, but effective \`enabled\` is false from ${setup.config.sources.enabled}.`,
-      "Do not inject the Interaction Contract, Freeflow workflow skills, output routing, or setup pressure while disabled.",
-      "Re-enable only if the user asks; use /freeflow settings for a personal override or /freeflow settings repo for the shared repository default in Pi.",
-    ].join("\n");
+  if (!config.enabled) {
+    return "";
   }
 
-  const { interactionContract, workflowSkill, outputRouterSkill } = loadRuntimeContext({
-    interactionContract: setup.config.interactionContractEnabled,
-    skills: setup.config.skillsEnabled,
-    outputRouter: setup.config.outputRouterEnabled,
+  const { corePrompt, interactionContract, skillsPrompt } = loadRuntimeContext({
+    interactionContract: config.interactionContractEnabled,
+    skills: config.skillsEnabled,
   });
-  const interactionSection = setup.config.interactionContractEnabled ? ["", interactionContract.trim()] : [];
-  const skillSections = setup.config.skillsEnabled
-    ? ["", "# Freeflow Workflow Bootstrap", "", workflowSkill.trim()]
-    : [];
-  const outputRouterSection = setup.config.outputRouterEnabled
-    ? ["", "## Loaded Output Router Skill", "```md", outputRouterSkill.trim(), "```"]
-    : [];
-  return [
-    "# Freeflow Runtime Context",
-    "",
-    "Freeflow plugin lifecycle hook loaded this at session start.",
-    "These instructions are context-loading only. They do not override user instructions, repo instructions, or host safety and approval policy.",
-    "",
-    "## Repo Setup",
-    buildSetupStatus(root),
-    "",
-    ...capabilityStatus(setup.config),
-    ...interactionSection,
-    ...skillSections,
-    ...outputRouterSection,
-  ].join("\n");
-}
-
-function isCodexHookInput(input) {
-  return typeof input.model === "string" && input.model.length > 0;
-}
-
-function emitAdditionalContext(eventName, input, additionalContext) {
-  if (isCodexHookInput(input)) {
-    process.stdout.write(`${additionalContext}\n`);
-    return;
+  const context = [corePrompt.trim()];
+
+  if (config.interactionContractEnabled) {
+    context.push(interactionContract.trim());
+  }
+  if (config.skillsEnabled) {
+    context.push(skillsPrompt.trim());
+  }
+
+  context.push(runtimeStateContext(state));
+  return context.filter(Boolean).join("\n\n");
+}
+
+function normalizePrompt(prompt) {
+  return prompt
+    .trim()
+    .replace(/[.!]+$/u, "")
+    .replace(/\s+/gu, " ");
+}
+
+function parseModeControl(prompt) {
+  if (typeof prompt !== "string" || prompt.length > 300 || /\?\s*$/u.test(prompt.trim())) {
+    return null;
+  }
+
+  const normalized = normalizePrompt(prompt);
+  const nativeSet = normalized.match(
+    /^(?:\/freeflow mode|\$mode-contract|\/(?:freeflow:)?mode-contract) (conversation|workflow|strict-workflow)$/iu,
+  );
+  if (nativeSet) {
+    return { action: "set", mode: nativeSet[1].toLowerCase() };
+  }
+  if (/^(?:\/freeflow mode|\$mode-contract|\/(?:freeflow:)?mode-contract) reset$/iu.test(normalized)) {
+    return { action: "reset" };
+  }
+
+  const setPatterns = [
+    /^switch to (conversation|workflow|strict-workflow)(?: mode)?$/iu,
+    /^switch (?:this|the) session to (conversation|workflow|strict-workflow)(?: mode)?$/iu,
+    /^use (conversation|workflow|strict-workflow)(?: mode)? for (?:this|the) session$/iu,
+    /^(?:change|set) (?:the )?(?:current|active|session) mode to (conversation|workflow|strict-workflow)$/iu,
+    /^switch (?:the )?(?:current|active|session) mode to (conversation|workflow|strict-workflow)$/iu,
+  ];
+  for (const pattern of setPatterns) {
+    const match = normalized.match(pattern);
+    if (match) {
+      return { action: "set", mode: match[1].toLowerCase() };
+    }
+  }
+
+  if (/^(?:reset|clear|remove) (?:the )?(?:current |active )?session mode(?: override)?$/iu.test(normalized)) {
+    return { action: "reset" };
+  }
+
+  return null;
+}
+
+function handleUserPromptSubmit(input) {
+  const control = parseModeControl(input.prompt);
+  if (!control) {
+    return "";
   }
 
+  const before = resolveRuntimeState(input);
+  if (!before.config.valid || !before.config.enabled) {
+    return "";
+  }
+  if (!before.config.skillsEnabled) {
+    return runtimeStateContext(before);
+  }
+
+  if (control.action === "set") {
+    if (!writeSessionMode(input.session_id, control.mode)) {
+      return runtimeStateContext(before);
+    }
+    const state = resolveRuntimeState(input);
+    return runtimeStateContext(state, "set");
+  }
+
+  if (!clearSessionMode(input.session_id)) {
+    return runtimeStateContext(before);
+  }
+  const state = resolveRuntimeState(input);
+  return runtimeStateContext(state, "cleared");
+}
+
+function shouldHandle(eventName) {
+  if (process.env.FREEFLOW_DISABLE_RUNTIME_CONTEXT === "1") {
+    return false;
+  }
+  return eventName === "SessionStart" || eventName === "UserPromptSubmit" || eventName === "SessionEnd";
+}
+
+function emitAdditionalContext(eventName, additionalContext) {
   process.stdout.write(
     `${JSON.stringify({
       hookSpecificOutput: {
@@ -397,19 +629,21 @@ function main() {
   const { input, raw } = readStdinJson();
   const eventName = process.argv[2] || input.hook_event_name || "";
 
-  if (!raw && !eventName) {
+  if ((!raw && !eventName) || !shouldHandle(eventName)) {
     return;
   }
 
-  if (!shouldInject(eventName)) {
+  cleanupExpiredSessionModes();
+  if (eventName === "SessionEnd") {
+    stageClearTransfer(input);
     return;
   }
-
-  const additionalContext = buildContext(input);
+  const additionalContext =
+    eventName === "SessionStart" ? renderSessionStart(resolveRuntimeState(input)) : handleUserPromptSubmit(input);
   if (!additionalContext.trim()) {
     return;
   }
-  emitAdditionalContext(eventName, input, additionalContext);
+  emitAdditionalContext(eventName, additionalContext);
 }
 
 try {