@epoch-ai/cli 2.2.4

package/src/session/prompt/engine.ts

@@ -0,0 +1,1072 @@
+import { Effect, Layer, ServiceMap, Scope, Exit, Cause } from "effect"
+import { generateText } from "ai"
+import { SessionID, MessageID, PartID } from "../schema"
+import { MessageV2 } from "../message-v2"
+import { Instance } from "../../project/instance"
+import { Log } from "../../util/log"
+import { Session } from "../index"
+import { Agent } from "../../agent/agent"
+import { Provider } from "../../provider/provider"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import * as Stream from "effect/Stream"
+import { Shell } from "../../shell/shell"
+import { Process } from "../../util/process"
+import { Plugin } from "../../plugin"
+import { AppFileSystem } from "../../filesystem"
+import { NamedError } from "@epoch-ai/util/error"
+import { ulid } from "ulid"
+import { InstanceState } from "@/effect/instance-state"
+import { InputResolver } from "./resolver"
+import { ToolOrchestrator } from "./orchestrator"
+import { SessionStatus } from "../status"
+import { SessionCompaction } from "../compaction"
+import { SessionProcessor } from "../processor"
+import { Instruction } from "../instruction"
+import { SystemPrompt } from "../system"
+import { SessionSummary } from "../summary"
+import { Bus } from "../../bus"
+import { PostGenerationWorker } from "../worker"
+import { STRUCTURED_OUTPUT_SYSTEM_PROMPT } from "./utils"
+import path from "path"
+import type { ShellInput } from "./types"
+import MAX_STEPS from "./max-steps.txt"
+
+export namespace SessionEngine {
+  const log = Log.create({ service: "session.prompt.engine" })
+
+  export interface Interface {
+    readonly runLoop: (sessionID: SessionID, yolo?: boolean) => Effect.Effect<MessageV2.WithParts>
+    readonly shellImpl: (input: ShellInput, signal: AbortSignal) => Effect.Effect<MessageV2.WithParts>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@epochcli/SessionPrompt/Engine") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const scope = yield* Scope.Scope
+      const bus = yield* Bus.Service
+      const sessions = yield* Session.Service
+      const agents = yield* Agent.Service
+      const provider = yield* Provider.Service
+      const plugin = yield* Plugin.Service
+      const fsys = yield* AppFileSystem.Service
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+      const status = yield* SessionStatus.Service
+      const compaction = yield* SessionCompaction.Service
+      const processor = yield* SessionProcessor.Service
+      const instruction = yield* Instruction.Service
+      const resolver = yield* InputResolver.Service
+      const orchestrator = yield* ToolOrchestrator.Service
+
+      const lastAssistant = (sessionID: SessionID) =>
+        Effect.promise(async () => {
+          let latest: MessageV2.WithParts | undefined
+          for await (const item of MessageV2.stream(sessionID)) {
+            latest ??= item
+            if (item.info.role !== "user") return item
+          }
+          if (latest) return latest
+          throw new Error("Impossible")
+        })
+
+      const shellImpl = Effect.fn("SessionPrompt.shellImpl")(function* (input: ShellInput, signal: AbortSignal) {
+        const ctx = yield* InstanceState.context
+        const session = yield* sessions.get(input.sessionID)
+        const agent = yield* agents.get(input.agent)
+        if (!agent) {
+          const available = (yield* agents.list()).filter((a) => !a.hidden).map((a) => a.name)
+          const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
+          const error = new NamedError.Unknown({ message: `Agent not found: "${input.agent}".${hint}` })
+          yield* bus.publish(Session.Event.Error, { sessionID: input.sessionID, error: error.toObject() })
+          throw error
+        }
+        const model = input.model ?? agent.model ?? (yield* resolver.lastModel(input.sessionID))
+        const userMsg: MessageV2.User = {
+          id: input.messageID ?? MessageID.ascending(),
+          sessionID: input.sessionID,
+          time: { created: Date.now() },
+          role: "user",
+          agent: input.agent,
+          model: { providerID: model.providerID, modelID: model.modelID },
+        }
+        yield* sessions.updateMessage(userMsg)
+        const userPart: MessageV2.Part = {
+          type: "text",
+          id: PartID.ascending(),
+          messageID: userMsg.id,
+          sessionID: input.sessionID,
+          text: "The following tool was executed by the user",
+          synthetic: true,
+        }
+        yield* sessions.updatePart(userPart)
+
+        const msg: MessageV2.Assistant = {
+          id: MessageID.ascending(),
+          sessionID: input.sessionID,
+          parentID: userMsg.id,
+          mode: input.agent,
+          agent: input.agent,
+          cost: 0,
+          path: { cwd: ctx.directory, root: ctx.worktree },
+          time: { created: Date.now() },
+          role: "assistant",
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          modelID: model.modelID,
+          providerID: model.providerID,
+        }
+        yield* sessions.updateMessage(msg)
+        const part: MessageV2.ToolPart = {
+          type: "tool",
+          id: PartID.ascending(),
+          messageID: msg.id,
+          sessionID: input.sessionID,
+          tool: "bash",
+          callID: ulid(),
+          state: {
+            status: "running",
+            time: { start: Date.now() },
+            input: { command: input.command },
+          },
+        }
+        yield* sessions.updatePart(part)
+
+        const sh = Shell.preferred()
+        const shellName = (
+          process.platform === "win32" ? path.win32.basename(sh, ".exe") : path.basename(sh)
+        ).toLowerCase()
+        const invocations: Record<string, { args: string[] }> = {
+          nu: { args: ["-c", input.command] },
+          fish: { args: ["-c", input.command] },
+          zsh: {
+            args: [
+              "-l",
+              "-c",
+              `
+                __oc_cwd=$PWD
+                [[ -f ~/.zshenv ]] && source ~/.zshenv >/dev/null 2>&1 || true
+                [[ -f "\${ZDOTDIR:-$HOME}/.zshrc" ]] && source "\${ZDOTDIR:-$HOME}/.zshrc" >/dev/null 2>&1 || true
+                cd "$__oc_cwd"
+                eval ${JSON.stringify(input.command)}
+              `,
+            ],
+          },
+          bash: {
+            args: [
+              "-l",
+              "-c",
+              `
+                __oc_cwd=$PWD
+                shopt -s expand_aliases
+                [[ -f ~/.bashrc ]] && source ~/.bashrc >/dev/null 2>&1 || true
+                cd "$__oc_cwd"
+                eval ${JSON.stringify(input.command)}
+              `,
+            ],
+          },
+          cmd: { args: ["/c", input.command] },
+          powershell: { args: ["-NoProfile", "-Command", input.command] },
+          pwsh: { args: ["-NoProfile", "-Command", input.command] },
+          "": { args: ["-c", input.command] },
+        }
+
+        const args = (invocations[shellName] ?? invocations[""]).args
+        const cwd = ctx.directory
+        const shellEnv = yield* plugin.trigger(
+          "shell.env",
+          { cwd, sessionID: input.sessionID, callID: part.callID },
+          { env: {} },
+        )
+
+        const cmd = ChildProcess.make(sh, args, {
+          cwd,
+          extendEnv: true,
+          env: { ...shellEnv.env, TERM: "dumb" },
+          stdin: "ignore",
+          forceKillAfter: "3 seconds",
+        })
+
+        let output = ""
+        let aborted = false
+
+        const finish = Effect.uninterruptible(
+          Effect.gen(function* () {
+            if (aborted) {
+              output += "\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n")
+            }
+            if (!msg.time.completed) {
+              msg.time.completed = Date.now()
+              yield* sessions.updateMessage(msg)
+            }
+            if (part.state.status === "running") {
+              part.state = {
+                status: "completed",
+                time: { ...part.state.time, end: Date.now() },
+                input: part.state.input,
+                title: "",
+                metadata: { output, description: "" },
+                output,
+              }
+              yield* sessions.updatePart(part)
+            }
+          }),
+        )
+
+        const exit = yield* Effect.gen(function* () {
+          const handle = yield* spawner.spawn(cmd)
+          yield* Stream.runForEach(Stream.decodeText(handle.all), (chunk) =>
+            Effect.sync(() => {
+              output += chunk
+              if (part.state.status === "running") {
+                part.state.metadata = { output, description: "" }
+                void Effect.runFork(sessions.updatePart(part))
+              }
+            }),
+          )
+          yield* handle.exitCode
+        }).pipe(
+          Effect.scoped,
+          Effect.onInterrupt(() =>
+            Effect.sync(() => {
+              aborted = true
+            }),
+          ),
+          Effect.orDie,
+          Effect.ensuring(finish),
+          Effect.exit,
+        )
+
+        if (Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause)) {
+          return yield* Effect.failCause(exit.cause)
+        }
+
+        return { info: msg, parts: [part] }
+      })
+
+      const runLoop: (sessionID: SessionID, yolo?: boolean) => Effect.Effect<MessageV2.WithParts> = Effect.fn(
+        "SessionPrompt.run",
+      )(function* (sessionID: SessionID, yolo?: boolean) {
+        const ctx = yield* InstanceState.context
+        let structured: unknown | undefined
+        let step = 0
+        let stallScore = 0
+        let lastAdvancingTarget: string | undefined
+        let forceTransition = false
+        const toolHistory: { tool: string; input: any }[] = []
+
+        // Tools that move the project state forward
+        const ADVANCING_TOOLS = ["edit", "write", "task_complete", "sc_todo_complete", "sc_archive", "sc_approve"]
+        // Tools that are neutral (read-only or state setup)
+        const NEUTRAL_TOOLS = [
+          "read",
+          "grep",
+          "glob",
+          "ls",
+          "pm_query",
+          "sc_status",
+          "sc_guidance",
+          "sc_todo_list",
+          "gt_status",
+          "sc_init",
+          "sc_plan",
+        ]
+        // Tools that indicate a failure or stuck state
+        const INVALID_TOOLS = ["invalid"]
+
+        const MAX_TURNS = 50
+        while (true) {
+          const session = yield* sessions.get(sessionID)
+          if (step > MAX_TURNS) {
+            log.error("MAX_TURNS exceeded. Forcing session termination.", { sessionID, step })
+            break
+          }
+          yield* status.set(sessionID, { type: "busy" })
+          log.info("loop", { step, sessionID })
+
+          let msgs = yield* MessageV2.filterByEpochEffect(sessionID)
+
+          let lastUser: MessageV2.User | undefined
+          let lastAssistantMsgObj: MessageV2.Assistant | undefined
+          let lastFinished: MessageV2.Assistant | undefined
+          let tasks: (MessageV2.TransitionPart | MessageV2.SubtaskPart)[] = []
+          for (let i = msgs.length - 1; i >= 0; i--) {
+            const msg = msgs[i]
+            if (!lastUser && msg.info.role === "user") lastUser = msg.info
+            if (!lastAssistantMsgObj && msg.info.role === "assistant") lastAssistantMsgObj = msg.info
+            if (!lastFinished && msg.info.role === "assistant" && msg.info.finish) lastFinished = msg.info
+            if (lastUser && lastFinished) break
+            const task = msg.parts.filter((part) => part.type === "transition" || part.type === "subtask")
+            if (task && !lastFinished) tasks.push(...task)
+          }
+
+          if (!lastUser) throw new Error("No user message found in stream. This should never happen.")
+
+          const model = yield* resolver.getModel(lastUser.model.providerID, lastUser.model.modelID, sessionID)
+
+          let currentTokensEstimate = 0
+          for (const m of msgs) {
+            if (m.info.role === "assistant" && m.info.tokens) {
+              // Only count output and reasoning tokens to avoid double-counting the history (input tokens)
+              currentTokensEstimate += (m.info.tokens.output || 0) + (m.info.tokens.reasoning || 0)
+            }
+
+            // For all messages (including assistant and user), we must account for the overhead
+            // of tool outputs and text parts that might not be fully reflected in the API's 'output' tokens
+            // (e.g. if tokens aren't reported or for user/system messages)
+            for (const p of m.parts) {
+              if (p.type === "text" && p.text) {
+                // Only add text length if it's a user message or assistant tokens weren't reported
+                if (m.info.role === "user" || !m.info.tokens?.output) {
+                  currentTokensEstimate += Math.ceil(p.text.length / 4)
+                }
+              }
+              if (p.type === "reasoning" && p.text && !(m.info.role === "assistant" && m.info.tokens?.reasoning)) {
+                currentTokensEstimate += Math.ceil(p.text.length / 4)
+              }
+              if (p.type === "tool" && "state" in p) {
+                // Tool inputs and outputs are always part of the context
+                currentTokensEstimate += Math.ceil(JSON.stringify(p.state.input).length / 4)
+                if (p.state.status === "completed" && p.state.output) {
+                  currentTokensEstimate += Math.ceil(p.state.output.length / 4)
+                } else if (p.state.status === "completed" && p.state.metadata?.output) {
+                  currentTokensEstimate += Math.ceil(p.state.metadata.output.length / 4)
+                }
+              }
+            }
+          }
+
+          const isHardOverflow =
+            lastFinished &&
+            lastFinished.summary !== true &&
+            (yield* compaction.isOverflow({ tokens: lastFinished.tokens, model }))
+          const isInputOverflow =
+            currentTokensEstimate > 0 &&
+            (yield* compaction.isOverflow({
+              tokens: {
+                input: currentTokensEstimate,
+                output: 0,
+                reasoning: 0,
+                cache: { read: 0, write: 0 },
+              },
+              model,
+            }))
+
+          if (forceTransition || isHardOverflow || isInputOverflow) {
+            const reason = isInputOverflow
+              ? "Input Overflow"
+              : forceTransition
+                ? "Emergency Handshake"
+                : "Hard Overflow"
+            forceTransition = false
+            log.info("Context limit reached. Initiating automatic Epoch transition.", {
+              sessionID,
+              reason,
+              tokens: isInputOverflow ? currentTokensEstimate : lastFinished ? lastFinished.tokens.total : 0,
+            })
+            yield* status.set(sessionID, { type: "busy" })
+
+            // Refetch chat history to ensure any partial tool calls/thoughts saved during the overflow turn are included
+            const latestMsgs = yield* MessageV2.filterByEpochEffect(sessionID)
+
+            yield* PostGenerationWorker.execute({
+              sessionID,
+              chatHistory: latestMsgs,
+              abortSignal: new AbortController().signal,
+              isTransition: true,
+            })
+
+            const fsNode = yield* Effect.promise(() => import("fs/promises"))
+            const continuityPath = path.join(Instance.directory, ".epoch-continuity.toon")
+            const interruptedPath = path.join(Instance.directory, ".history", "interrupted_state.toon")
+
+            let continuityReport = ""
+            let interruptedState = ""
+
+            continuityReport = yield* Effect.promise(() => fsNode.readFile(continuityPath, "utf-8").catch(() => ""))
+            interruptedState = yield* Effect.promise(() => fsNode.readFile(interruptedPath, "utf-8").catch(() => ""))
+
+            let rationale = "Context limit reached. Transitioning to new epoch."
+            let nextCall = ""
+            if (continuityReport) {
+              const rationaleMatch = continuityReport.match(/rationale: '([\s\S]+?)'/)
+              const exampleMatch = continuityReport.match(/example_input: (\{[\s\S]+?\})/)
+              const toolMatch = continuityReport.match(/tool: '(\w+)'/)
+
+              if (rationaleMatch) rationale = rationaleMatch[1]
+              if (toolMatch && exampleMatch) {
+                nextCall = `Suggested next call: \`${toolMatch[1]}(${exampleMatch[1]})\``
+              }
+            }
+
+            // Extract dynamic task ID
+            let firstPendingTaskId = ""
+            try {
+              const activeProjectsDir = path.join(Instance.directory, "projects", "active")
+              const projects = yield* Effect.promise(() => fsNode.readdir(activeProjectsDir).catch(() => []))
+              if (projects.length > 0) {
+                const tasksPath = path.join(activeProjectsDir, projects[0], "Tasks.json")
+                const tasksContent = yield* Effect.promise(() => fsNode.readFile(tasksPath, "utf-8").catch(() => ""))
+                if (tasksContent) {
+                  const tasksJson = JSON.parse(tasksContent)
+                  if (tasksJson.tasks && Array.isArray(tasksJson.tasks)) {
+                    const pendingTask = tasksJson.tasks.find((t: any) => t.status !== "completed")
+                    if (pendingTask && pendingTask.id) {
+                      firstPendingTaskId = String(pendingTask.id)
+                    } else if (tasksJson.tasks[0]?.id) {
+                      firstPendingTaskId = String(tasksJson.tasks[0].id)
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              log.debug("Failed to extract dynamic task ID for handover", { error: String(e) })
+            }
+
+            const actualLastUserMsg = latestMsgs.findLast((m) => m.info.role === "user")
+            const currentAgent = actualLastUserMsg?.info.agent ?? lastUser.agent
+
+            let conversationalMsg = ""
+            const firstTaskNote = firstPendingTaskId ? `id="${firstPendingTaskId}"` : `id="1.1"`
+            const activeTaskNote = firstPendingTaskId ? `Your current or next task ID is ${firstPendingTaskId}.` : ""
+
+            if (currentAgent === "plan") {
+              // Type 1: Planning Phase
+              conversationalMsg = `Hi, we are continuing the planning phase of the project as the context window ran out and we are starting a new chat to resume from before. 
+
+The following detailed history resources are available in the \`.history/\` directory to support your orientation:
+- \`.history/interrupted_state.toon\`: Your exact mental state, partial drafts, and intended next tool call right before the transition. READ THIS FIRST.
+- \`.history/timeline.toon\`: Detailed chronological log of all tool calls and outputs from the previous epoch.
+- \`.history/intent.toon\`: The longitudinal architectural roadmap and decisions established so far.
+
+Based on the continuity report, you were in the middle of: ${rationale}.
+${nextCall ? `NEXT ACTION: ${nextCall}. Proceed directly to this action.` : ""}
+
+CRITICAL: Continue focusing on discovery, architecture mapping, and drafting specifications or tasks. You MUST conclude this phase with 'mcpx spec sc_approve'.`
+            } else if (currentAgent === "build" && reason === "Emergency Handshake") {
+              // Type 2: First Handover to Build Phase (The Kickoff)
+              conversationalMsg = `ORIENTATION_REQUIREMENTS: SATISFIED. Deep Inception applied. You are in the Build Phase.
+
+The following detailed history resources are available in the \`.history/\` directory to support your orientation:
+- \`.history/timeline.toon\`: Detailed chronological log of all tool calls and outputs from the previous epoch.
+- \`.history/intent.toon\`: The longitudinal architectural roadmap and decisions established so far.
+
+Based on the continuity report, you were in the middle of: ${rationale}.
+
+CRITICAL: Your IMMEDIATE first action MUST be to execute \`mcpx spec sc_todo_start\` for the first task (e.g., ${firstTaskNote}). 
+You are EXPRESSLY FORBIDDEN from executing redundant reads of \`Specification.md\` or \`Tasks.json\`. DO NOT repeat discovery.
+
+Lets get straight on with implementation work`
+            } else {
+              // Type 3: Continue the Build Phase
+              conversationalMsg = `Hi, we are continuing the build phase of the project as the context window ran out and we are starting a new chat to resume from before.
+
+              The following detailed history resources are available in the \`.history/\` directory to support your orientation:
+              - \`.history/interrupted_state.toon\`: Your exact mental state, partial drafts, and intended next tool call right before the transition. READ THIS FIRST.
+              - \`.history/timeline.toon\`: Detailed chronological log of all tool calls and outputs from the previous epoch.
+              - \`.history/intent.toon\`: The longitudinal architectural roadmap and decisions established so far.
+
+              Based on the continuity report, you were in the middle of: ${rationale}.
+              ${nextCall ? `NEXT ACTION: ${nextCall}. Proceed directly to this action.` : ""}
+
+              CRITICAL: ORIENTATION_REQUIREMENTS: SATISFIED.
+              ${activeTaskNote}
+              - If you need to review the specification, use \`read\` on \`projects/active/<feature>/Specification.md\` or \`Tasks.json\`.
+              - If you need codebase context, ALWAYS prefer using \`mcpx map context\` or \`mcpx map fetch\` instead of repetitive \`read\` loops on large files.
+              - If you are unsure of your current task, use \`mcpx spec sc_status\`.
+
+              Let's get straight on with continuing our work.`            }
+
+            const newParentId = MessageID.ascending()
+            yield* sessions.updateMessage({
+              id: newParentId,
+              sessionID,
+              role: "user",
+              time: { created: Date.now() },
+              agent: lastUser.agent,
+              model: lastUser.model,
+            })
+            yield* sessions.updatePart({
+              id: PartID.ascending(),
+              sessionID,
+              messageID: newParentId,
+              type: "transition",
+              auto: true,
+            })
+
+            const nextTurnId = MessageID.ascending()
+            yield* sessions.updateMessage({
+              id: nextTurnId,
+              sessionID,
+              role: "user",
+              time: { created: Date.now() },
+              agent: lastUser.agent,
+              model: lastUser.model,
+            })
+            yield* sessions.updatePart({
+              id: PartID.ascending(),
+              sessionID,
+              messageID: nextTurnId,
+              type: "text",
+              synthetic: true,
+              text: conversationalMsg,
+            })
+
+            continue
+          }
+
+          const lastAssistantMsg = msgs.findLast(
+            (msg) => msg.info.role === "assistant" && msg.info.id === lastAssistantMsgObj?.id,
+          )
+          const toolParts =
+            lastAssistantMsg?.parts.filter((part): part is MessageV2.ToolPart => part.type === "tool") ?? []
+          const hasToolCalls = toolParts.length > 0
+
+          // Update stall score
+          const advancingParts = toolParts.filter((p) => ADVANCING_TOOLS.includes(p.tool))
+          let isAdvancing = false
+          for (const p of advancingParts) {
+            const target = (p.state.input as any)?.filePath || p.tool
+            if (target !== lastAdvancingTarget) {
+              isAdvancing = true
+              lastAdvancingTarget = target
+              break
+            }
+          }
+
+          const isInvalid = toolParts.some((p) => INVALID_TOOLS.includes(p.tool))
+          const isOrientation = toolParts.some(
+            (p) =>
+              p.tool === "glob" ||
+              (p.tool === "bash" &&
+                typeof (p.state as any)?.input?.command === "string" &&
+                ((p.state as any).input.command.startsWith("ls ") || (p.state as any).input.command.startsWith("find "))),
+          )
+          const lastTurnTools = toolHistory.slice(-toolParts.length)
+          const isIdenticalRepetition =
+            toolParts.length > 0 &&
+            JSON.stringify(toolParts.map((p) => ({ t: p.tool, i: p.state.input }))) ===
+              JSON.stringify(lastTurnTools.map((p) => ({ t: p.tool, i: p.input })))
+
+          let stallReason: "repetition" | "neutral" | "invalid_args" | "orientation_loop" | "empty_turn" | "rambling_hallucination" | "text_loop" | undefined
+          const offendingTools = toolParts.map((p) => p.tool)
+
+          if (isAdvancing) {
+            stallScore = 0
+            step = 0
+          } else if (isIdenticalRepetition) {
+            stallScore += 5
+            stallReason = "repetition"
+          } else if (isInvalid) {
+            stallScore += 5
+            stallReason = "invalid_args"
+          } else if (isOrientation) {
+            stallScore += 3
+            stallReason = "orientation_loop"
+          } else if (toolParts.length > 0) {
+            stallScore += 1
+            stallReason = "neutral"
+          } else if (lastAssistantMsgObj && (session.yolo || yolo)) {
+            // Empty Action Penalty: In YOLO mode, a text-only response without tool calls
+            // is a strong indicator of a stall or internal debate loop.
+            stallScore += 10
+            stallReason = "empty_turn"
+          }
+
+          for (const part of toolParts) {
+            if (part.state.status !== "pending") {
+              toolHistory.push({ tool: part.tool, input: part.state.input })
+              if (toolHistory.length > 10) toolHistory.shift()
+            }
+          }
+
+          // Handle in-stream rambling aborts from the previous turn
+          if (lastAssistantMsgObj?.error && MessageV2.RamblingError.isInstance(lastAssistantMsgObj.error)) {
+            stallScore = 15 // Force immediate intervention
+            stallReason =
+              (lastAssistantMsgObj.error as any).data?.reason === "STREAM_ABORT_RAMBLING"
+                ? "rambling_hallucination"
+                : "text_loop"
+          }
+
+          if (stallScore >= 20 && (session.yolo || yolo)) {
+            log.error("Terminal stagnation (Score 20+) - triggering Hard Reset", { sessionID, stallScore })
+            forceTransition = true
+            stallScore = 0
+          }
+
+          if (!forceTransition && stallScore >= 15) {
+            const isAlreadyIntervened = msgs.some(m => m.info.role === "user" && m.parts.some(p => p.type === "text" && p.text.includes("Stall Reason:")))
+            if (!isAlreadyIntervened) {
+              log.error("Terminal stagnation detected - triggering intervention", {
+                sessionID,
+                stallScore,
+                stallReason,
+                offendingTools,
+                toolHistory,
+              })
+              const hintStr = `Stall Reason: ${stallReason}.${offendingTools.length > 0 ? ` Offending Tools: ${offendingTools.join(", ")}` : ""}`
+              yield* sessions.setInterventionHint({ sessionID, hint: hintStr })
+              yield* sessions.setInterventionRequested({ sessionID, requested: true })
+              // Note: We no longer reset stallScore here to allow it to climb to 20 if the intervention is ignored
+              continue // Loop back to pick up the intervention in Phase 1
+            }
+          }
+
+          if (!forceTransition && stallScore >= 10 && (session.yolo || yolo)) {
+            const isAlreadyNudged = msgs.some(m => m.info.role === "user" && m.parts.some(p => p.type === "text" && p.text.includes("[System: You appear to be stalling")))
+            if (!isAlreadyNudged) {
+              log.warn("Stall detected - injecting nudge", { sessionID, stallScore, stallReason, offendingTools })
+              let nudgeText =
+                "[System: You appear to be stalling or repeating operations without making progress. Please reconsider your strategy or attempt a more direct action to advance the project state.]"
+
+              if (
+                stallReason === "invalid_args" &&
+                toolParts.some((p) => (p.state as any).input?.tool === "mcpx" || p.tool === "mcpx")
+              ) {
+                nudgeText =
+                  "[System: Your last mcpx tool calls failed due to invalid syntax. REMINDER: positional flags like '--name' MUST be passed as an array of strings in the 'args' parameter, NOT as keys in the 'flags' object. Please run 'mcpx spec --help' to verify the interface.]"
+              } else if (stallReason === "orientation_loop") {
+                nudgeText =
+                  "[System: You are using manual file exploration tools for codebase navigation. The workspace map is active. Please use 'mcpx' with server='map' and tool='pm_query' for context-aware discovery. ('glob' may still be used for mass edits).]"
+              }
+
+              const newMsgId = MessageID.ascending()
+              const newUserMsg: MessageV2.User = {
+                id: newMsgId,
+                sessionID,
+                role: "user",
+                time: { created: Date.now() },
+                model: lastUser.model,
+                agent: lastUser.agent,
+              }
+              yield* sessions.updateMessage(newUserMsg)
+              yield* sessions.updatePart({
+                id: PartID.ascending(),
+                sessionID,
+                messageID: newMsgId,
+                type: "text",
+                synthetic: true,
+                text: nudgeText,
+              })
+              lastUser = newUserMsg
+              // Note: We no longer reset stallScore here to allow it to climb to 15/20
+              continue
+            }
+          }
+
+          if (
+            lastAssistantMsgObj?.finish &&
+            !["tool-calls"].includes(lastAssistantMsgObj.finish) &&
+            !hasToolCalls &&
+            lastUser.id < lastAssistantMsgObj.id
+          ) {
+            const isYolo =
+              session.yolo ||
+              yolo ||
+              msgs.some(
+                (m) =>
+                  m.info.role === "user" &&
+                  m.parts.some((p) => p.type === "text" && p.text.includes("[System: YOLO mode enabled")),
+              )
+            const hasTaskComplete = msgs.some(
+              (m) =>
+                m.info.role === "assistant" && m.parts.some((p) => p.type === "tool" && p.tool === "task_complete"),
+            )
+
+            if (isYolo && !hasTaskComplete) {
+              log.info("YOLO mode active. Auto-continuing after text response.", { sessionID })
+
+              let nudgeText =
+                "[SYSTEM: You provided a text response but have not yet called 'task_complete'. In YOLO mode, you must continue until the entire task is finished. If you are actually done, call 'task_complete' now. Otherwise, proceed with the next logical step (e.g., sc_plan, sc_approve, or implementation).]"
+
+              // Dynamically find the last spec status to provide a better nudge
+              const lastSpecMsg = [...msgs]
+                .reverse()
+                .find((m) =>
+                  m.parts.some(
+                    (p) =>
+                      p.type === "tool" &&
+                      p.state.status === "completed" &&
+                      (p.tool === "sc_status" ||
+                        (p.tool === "bash" &&
+                          typeof p.state.output === "string" &&
+                          p.state.output.includes("Project:"))),
+                  ),
+                )
+              const lastSpecPart = lastSpecMsg?.parts.find(
+                (p): p is MessageV2.ToolPart => p.type === "tool" && p.state.status === "completed",
+              )
+              const specOutput =
+                lastSpecPart && lastSpecPart.state.status === "completed" ? lastSpecPart.state.output : undefined
+
+              if (specOutput) {
+                const nextStepMatch = specOutput.match(/Next Step: (.*)/)
+                const nextStep = nextStepMatch ? nextStepMatch[1].trim() : "Unknown"
+
+                if (specOutput.includes("All tasks completed")) {
+                  nudgeText = `[SYSTEM: All tasks are marked complete in 'spec sc_status'. If you are truly finished, you MUST call 'task_complete' now to close the session. Do not perform redundant validations.]`
+                } else {
+                  nudgeText = `[SYSTEM: You are currently in the middle of a workflow. Your last status check indicated the Next Step is: "${nextStep}". Please continue until the EventBus is fully implemented and tested. Do not exit via text.]`
+                }
+              }
+
+              const newMsgId = MessageID.ascending()
+              const newUserMsg: MessageV2.User = {
+                id: newMsgId,
+                sessionID,
+                role: "user",
+                time: { created: Date.now() },
+                model: lastUser.model,
+                agent: lastUser.agent,
+              }
+              yield* sessions.updateMessage(newUserMsg)
+              yield* sessions.updatePart({
+                id: PartID.ascending(),
+                sessionID,
+                messageID: newMsgId,
+                type: "text",
+                synthetic: true,
+                text: nudgeText,
+              })
+              lastUser = newUserMsg
+              continue
+            }
+            log.info("exiting loop", { sessionID })
+            break
+          }
+
+          step++
+          if (step === 1)
+            yield* resolver
+              .ensureTitle({
+                session,
+                modelID: lastUser.model.modelID,
+                providerID: lastUser.model.providerID,
+                history: msgs,
+              })
+              .pipe(Effect.ignore, Effect.forkIn(scope))
+
+          const task = tasks.pop()
+
+          if (task?.type === "subtask") {
+            yield* orchestrator.handleSubtask({ task, model, lastUser, sessionID, session, msgs })
+            continue
+          }
+
+          const agent = yield* agents.get(lastUser.agent)
+          if (!agent) {
+            const available = (yield* agents.list()).filter((a) => !a.hidden).map((a) => a.name)
+            const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
+            const error = new NamedError.Unknown({ message: `Agent not found: "${lastUser.agent}".${hint}` })
+            yield* bus.publish(Session.Event.Error, { sessionID, error: error.toObject() })
+            throw error
+          }
+          const maxSteps = agent.steps ?? Infinity
+          const isLastStep = step >= maxSteps
+          msgs = yield* resolver.insertReminders({ messages: msgs, agent, session })
+
+          const msg: MessageV2.Assistant = {
+            id: MessageID.ascending(),
+            parentID: lastUser.id,
+            role: "assistant",
+            mode: agent.name,
+            agent: agent.name,
+            variant: lastUser.model.variant,
+            path: { cwd: ctx.directory, root: ctx.worktree },
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            modelID: model.id,
+            providerID: model.providerID,
+            time: { created: Date.now() },
+            sessionID,
+          }
+          yield* sessions.updateMessage(msg)
+          const handle = yield* processor.create({
+            assistantMessage: msg,
+            sessionID,
+            model,
+          })
+
+          const outcome: "break" | "continue" | "compact" = yield* Effect.onExit(
+            Effect.gen(function* () {
+              const lastUserMsg = msgs.findLast((m) => m.info.role === "user")
+              const bypassAgentCheck = lastUserMsg?.parts.some((p) => p.type === "agent") ?? false
+
+              const lastNonSyntheticUser = msgs.findLast(
+                (m) => m.info.role === "user" && !m.parts.some((p) => p.type === "text" && p.synthetic),
+              )
+              let parentPermission = undefined
+              if (lastNonSyntheticUser && lastNonSyntheticUser.info.agent !== agent.name) {
+                const parentAgent = yield* agents.get(lastNonSyntheticUser.info.agent)
+                if (parentAgent) {
+                  parentPermission = parentAgent.permission
+                }
+              }
+
+              const tools = yield* orchestrator.resolveTools({
+                agent,
+                session,
+                model,
+                tools: lastUser.tools,
+                processor: handle,
+                bypassAgentCheck,
+                messages: msgs,
+                parentPermission,
+              })
+
+              if (lastUser.format?.type === "json_schema") {
+                tools["StructuredOutput"] = orchestrator.createStructuredOutputTool({
+                  schema: lastUser.format.schema,
+                  onSuccess(output) {
+                    structured = output
+                  },
+                })
+              }
+
+              if (step === 1) SessionSummary.summarize({ sessionID, messageID: lastUser.id })
+
+              if (step > 1 && lastFinished) {
+                for (const m of msgs) {
+                  if (m.info.role !== "user" || m.info.id <= lastFinished.id) continue
+                  for (const p of m.parts) {
+                    if (p.type !== "text" || p.ignored || p.synthetic) continue
+                    if (!p.text.trim()) continue
+                    p.text = [
+                      "<system-reminder>",
+                      "The user sent the following message:",
+                      p.text,
+                      "",
+                      "Please address this message and continue with your tasks.",
+                      "</system-reminder>",
+                    ].join("\n")
+                  }
+                }
+              }
+
+              yield* plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
+
+              const [skills, env, instructions, _modelMsgs, sysPaths, opFacts] = yield* Effect.all([
+                Effect.promise(() => SystemPrompt.skills(agent)),
+                Effect.promise(() => SystemPrompt.environment(model)),
+                instruction.system().pipe(Effect.orDie),
+                Effect.promise(() => MessageV2.toModelMessages(msgs, model)),
+                instruction.systemPaths().pipe(Effect.orDie),
+                Effect.promise(() => SystemPrompt.operationalFacts(model)),
+              ])
+              let modelMsgs = _modelMsgs
+
+              // Global Intervention Handler
+              if (session.interventionRequested && yolo) {
+                const hint = session.interventionHint
+                log.warn("Processing requested intervention", { sessionID, hint })
+
+                let continuityContext = ""
+                const continuityPath = Array.from(sysPaths).find((p) => p.endsWith(".epoch-continuity.toon"))
+                if (continuityPath) {
+                  try {
+                    const fsNode = yield* Effect.promise(() => import("fs/promises"))
+                    const content = yield* Effect.promise(() => fsNode.readFile(continuityPath, "utf-8"))
+                    continuityContext = `\n\nContext (Epoch Continuity Report):\n${content}\n`
+                  } catch (e) {}
+                }
+
+                const sideModel = yield* Effect.promise(() => Provider.getSideModel())
+                const sideLanguage = yield* Effect.promise(() => Provider.getLanguage(sideModel!))
+                const systemPrompt =
+                  "You are an AI supervisor monitoring a main agent. The main agent has stagnated or hit a terminal loop. Analyze the provided Context and the Stall Reason. Provide a concise, stern directive telling the agent EXACTLY what to do next to break the cycle. Do not output anything other than the directive."
+                const prompt = `Stall Reason: ${hint}${continuityContext}\n\nPlease provide the intervention directive:`
+
+                const intervention = yield* Effect.promise(() =>
+                  generateText({
+                    model: sideLanguage,
+                    system: systemPrompt,
+                    prompt,
+                    abortSignal: new AbortController().signal,
+                  }),
+                )
+
+                if (intervention.text) {
+                  const newMsgId = MessageID.ascending()
+                  const newUserMsg: MessageV2.User = {
+                    id: newMsgId,
+                    sessionID,
+                    role: "user",
+                    time: { created: Date.now() },
+                    agent: lastUser.agent,
+                    model: lastUser.model,
+                  }
+                  yield* sessions.updateMessage(newUserMsg)
+                  const newUserPart: MessageV2.Part = {
+                    type: "text",
+                    id: PartID.ascending(),
+                    messageID: newMsgId,
+                    sessionID,
+                    text: `[CRITICAL INTERVENTION]\n${intervention.text}`,
+                    synthetic: true,
+                  }
+                  yield* sessions.updatePart(newUserPart)
+                  yield* sessions.setInterventionRequested({ sessionID, requested: false })
+                  yield* sessions.setInterventionHint({ sessionID, hint: "" })
+
+                  return "continue"
+                }
+              }
+
+              const continuityPath = path.join(ctx.directory, ".epoch-continuity.toon")
+              const isContinue = yield* fsys.existsSafe(continuityPath)
+
+              // Epoch Cold-Start Injection
+              // If this is the first turn and we have a continuity report, inject it as a conversational message
+              // unless we already have a transition part in the history (which means it's an auto-transition).
+              if (step === 1 && isContinue && !msgs.some(m => m.parts.some(p => p.type === "transition"))) {
+                log.info("Cold-start detected. Injecting continuity context.")
+                let continuityReport = ""
+                try {
+                  const fsNode = yield* Effect.promise(() => import("fs/promises"))
+                  continuityReport = yield* Effect.promise(() => fsNode.readFile(continuityPath, "utf-8"))
+                } catch (e) {
+                  log.warn("Failed to read continuity report for cold-start injection", { error: String(e) })
+                }
+
+                if (continuityReport) {
+                  // Extract rationale and next action for immediate momentum
+                  let rationale = "Continuing previous task."
+                  let nextCall = ""
+                  const rationaleMatch = continuityReport.match(/rationale: '([\s\S]+?)'/)
+                  const exampleMatch = continuityReport.match(/example_input: (\{[\s\S]+?\})/)
+                  const toolMatch = continuityReport.match(/tool: '(\w+)'/)
+
+                  if (rationaleMatch) rationale = rationaleMatch[1]
+                  if (toolMatch && exampleMatch) {
+                    nextCall = `Suggested next call: \`${toolMatch[1]}(${exampleMatch[1]})\``
+                  }
+
+                  const conversationalMsg = `Hi, we are resuming work from a previous session.
+
+The following detailed history resources are available in the \`.history/\` directory to support your orientation:
+- \`.history/timeline.toon\`: Detailed chronological log of all tool calls and outputs from previous sessions.
+- \`.history/intent.toon\`: The longitudinal architectural roadmap and decisions established so far.
+
+Based on the continuity report, you were in the middle of: ${rationale}.
+${nextCall ? `NEXT ACTION: ${nextCall}. Proceed directly to this action.` : ""}
+
+CRITICAL: Do NOT use discovery tools (read, ls, pm_query, sc_status) for your first 3 turns of this new epoch. Trust the provided reports and proceed directly to implementation.
+
+Lets get straight on with continuing our work`
+
+                  const injectMsgId = MessageID.ascending()
+                  yield* sessions.updateMessage({
+                    id: injectMsgId,
+                    sessionID,
+                    role: "user",
+                    time: { created: Date.now() },
+                    agent: lastUser.agent,
+                    model: lastUser.model,
+                  })
+                  yield* sessions.updatePart({
+                    id: PartID.ascending(),
+                    sessionID,
+                    messageID: injectMsgId,
+                    type: "text",
+                    synthetic: true,
+                    text: conversationalMsg,
+                  })
+
+                  // Refresh messages to include the newly injected message
+                  msgs = yield* MessageV2.filterByEpochEffect(sessionID)
+                  modelMsgs = yield* Effect.promise(() => MessageV2.toModelMessages(msgs, model))
+                }
+              }
+
+              const CONTEXT_LIMIT = model.limit.context ?? 32000
+              const HIGH_WATERMARK = CONTEXT_LIMIT * 0.85
+              const wrapUpDirective =
+                currentTokensEstimate >= HIGH_WATERMARK
+                  ? "CRITICAL: Context limit approaching. Finalize the immediate sub-task, do not initiate new architectural changes, and output your final <|tool_call|> to commit current state."
+                  : ""
+
+              const format = lastUser.format ?? { type: "text" as const }
+
+              const zone1 = [...(wrapUpDirective ? [wrapUpDirective] : []), ...env, ...(skills ? [skills] : [])]
+              if (format.type === "json_schema") zone1.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT)
+
+              const system = {
+                zone1: zone1.filter(Boolean),
+                zone2: instructions.filter(Boolean),
+              }
+
+              const result = yield* handle.process({
+                user: lastUser,
+                agent,
+                permission: session.permission,
+                sessionID,
+                parentSessionID: session.parentID,
+                system,
+                operationalFacts: opFacts,
+                isContinue,
+                yolo:
+                  yolo ||
+                  msgs.some(
+                    (m) =>
+                      m.info.role === "user" && m.parts.some((p) => p.type === "text" && /yolo mode/i.test(p.text)),
+                  ),
+                messages: [...modelMsgs, ...(isLastStep ? [{ role: "assistant" as const, content: MAX_STEPS }] : [])],
+                tools,
+                model,
+                toolChoice: format.type === "json_schema" ? "required" : undefined,
+              })
+
+              // Maintain Epoch Continuity report in the background (unless compacting, which handles it synchronously)
+              if (result !== "compact") {
+                yield* PostGenerationWorker.execute({
+                  sessionID,
+                  chatHistory: msgs,
+                  abortSignal: new AbortController().signal,
+                }).pipe(Effect.ignore, Effect.forkIn(scope))
+              }
+
+              if (structured !== undefined) {
+                handle.message.structured = structured
+                handle.message.finish = handle.message.finish ?? "stop"
+                yield* sessions.updateMessage(handle.message)
+                return "break" as const
+              }
+
+              const finished = handle.message.finish && !["tool-calls", "unknown"].includes(handle.message.finish)
+              if (finished && !handle.message.error) {
+                if (format.type === "json_schema") {
+                  handle.message.error = new MessageV2.StructuredOutputError({
+                    message: "Model did not produce structured output",
+                    retries: 0,
+                  }).toObject()
+                  yield* sessions.updateMessage(handle.message)
+                  return "break" as const
+                }
+              }
+
+              if (result === "stop") return "break" as const
+              if (result === "compact") return "compact" as const
+              return "continue" as const
+            }),
+            Effect.fnUntraced(function* (exit) {
+              if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) yield* handle.abort()
+              yield* InstanceState.withALS(() => instruction.clear(handle.message.id)).pipe(Effect.flatMap((x) => x))
+            }),
+          )
+          if (outcome === "break") break
+          if (outcome === "compact") {
+            forceTransition = true
+          }
+          continue
+        }
+
+        return yield* lastAssistant(sessionID)
+      })
+
+      return Service.of({
+        runLoop,
+        shellImpl,
+      })
+    }),
+  )
+}