fix(core): complete goal-driver API sync started in eeeac7e

Adapt the remaining desynced consumers to the restructured goal driver:

- goal-tick-port: inline the single-tick body (pause/stop checks + one
  loop.tick + status publish); the goal-steer relay (makeGoalSteerRelay,
  GOAL_STEER_DELIVERY, pendingSteer/markSteerConsumed ports) was removed
  from goal-driver/goal-loop-wiring/core goal-loop, so drop its wiring
  here and in v4-event-runtime (steerBuffer no longer needed).
- multi-agent-runtime: drop the §C1 maxFilesChanged and §E2
  maxTokensPerHour gates plus the token-budget tracker — both limit
  fields were removed from the agent limits schema, making the gates
  dead code.
- Delete test files pinning removed APIs: goal-steer (steer relay),
  overflow (soft-landing state machine), plan-status-cache (volatile-tail
  cache design abandoned by the restructure), httpapi-webhook (webhook
  API dropped in 1db089f); trim removed-API cases from steer,
  multi-agent-runtime and model-discovery tests; adapt
  goal-tick-cold-recovery to the single-tick port.

typecheck in packages/deepagent-code goes from 75 errors to 0. Four
runtime test failures in steer/multi-agent-runtime predate this change
(baseline: 8 failures on the same two files) and remain as restructure
follow-up.

Author: thomas-yanga

packages/deepagent-code/src/session/goal-tick-port.ts

@@ -14,12 +14,11 @@ import type { Session } from "./session"
 import type { Agent } from "../agent/agent"
 import type { SessionPrompt } from "./prompt"
 import type { SessionRevert } from "./revert"
-import type { SessionSteer } from "./steer"
 import type { Provider } from "../provider/provider"
 import type { LSP } from "../lsp/lsp"
 import type { RuntimeFlags } from "../effect/runtime-flags"
 import { SessionID } from "./schema"
-import { GoalDriver, type GoalDriverPorts } from "./goal-driver"
+import { type GoalDriverPorts } from "./goal-driver"
 import {
   GoalLoopWiring,
   liveDiagnostics,
@@ -57,7 +56,6 @@ export type GoalTickPortDeps = {
   readonly agents: Agent.Interface
   readonly sessionPrompt: SessionPrompt.Interface
   readonly revert: SessionRevert.Interface
-  readonly steerBuffer: SessionSteer.Interface
   readonly provider: Provider.Interface
   readonly lsp: LSP.Interface
   readonly instanceStore: InstanceStore.Interface
@@ -182,9 +180,6 @@ export const makeGoalTickPort =
       )
       const wrappedRollback: typeof rollback = (rbInput) => withContext(rollback(rbInput))
 
-      // One goal-steer relay per tick, shared by the wiring (executor threads staged guidance) + the driver.
-      const steerRelay = GoalDriver.makeGoalSteerRelay()
-
       const deps_ = yield* GoalLoopWiring.makeGoalLoopWiring({
         store,
         parentSessionID: sessionID,
@@ -193,7 +188,6 @@ export const makeGoalTickPort =
         panelQuestion: defaultPanelQuestion,
         diagnostics,
         rollback: wrappedRollback,
-        steerRelay,
       }).pipe(Effect.provideService(RuntimeFlagsService.Service, deps.flags))
       if (deps_ == null) {
         log.warn("goal tick: goal loop disabled (experimentalGoalLoop off); halting chain", { sessionID })
@@ -213,34 +207,40 @@ export const makeGoalTickPort =
       })
 
       // Ports from DURABLE sources (no in-memory control map on the cold fiber):
-      //   • shouldPause / shouldStop — the session-state active-goal pointer phase (pause/stop persist it).
-      //   • goal-steer — the SessionSteer buffer on the goal session id + goal_steer delivery channel.
+      // shouldPause / shouldStop read the session-state active-goal pointer phase (pause/stop persist it).
       const goalPhase = () => AgentGateway.DeepAgentSessionState.getActiveGoal(sessionID)?.phase
       const ports: GoalDriverPorts = {
         onStatus: (status) => statusPublisher.publishStatus(sessionID, status),
         shouldPause: () => Effect.sync(() => goalPhase() === "paused"),
         shouldStop: () => Effect.sync(() => goalPhase() === "stopped"),
-        pendingSteer: () =>
-          deps.steerBuffer.pending(SessionID.make(sessionID), GoalDriver.GOAL_STEER_DELIVERY).pipe(
-            Effect.map((rows) => rows.map((r) => ({ id: r.id, text: r.prompt.text }))),
-            Effect.catchCause(() => Effect.succeed([] as ReadonlyArray<GoalDriver.PendingGoalSteer>)),
-          ),
-        markSteerConsumed: (ids) =>
-          deps.steerBuffer
-            .markConsumed(SessionID.make(sessionID), [...ids], GoalDriver.GOAL_STEER_DELIVERY)
-            .pipe(Effect.catchCause(() => Effect.void)),
       }
 
+      // One tick with the driver's cooperative pause/stop checks (the body of runToCompletion, minus the
+      // iteration — the event chain re-emits the next command instead of looping in-process).
+      const loop = makeGoalLoop(deps_)
       const handle = { goalId: request.goalId, planDocId: request.planDocId, sessionId: sessionID }
-      const result = yield* GoalDriver.runOneTick(makeGoalLoop(deps_), { deps: deps_, handle, ports, steerRelay })
+      const progress = yield* Effect.gen(function* () {
+        if (yield* ports.shouldStop().pipe(Effect.catchCause(() => Effect.succeed(false)))) {
+          yield* loop.stop(handle).pipe(Effect.catchCause(() => Effect.void))
+          return "stopped" as const
+        }
+        if (yield* ports.shouldPause().pipe(Effect.catchCause(() => Effect.succeed(false)))) {
+          return "paused" as const
+        }
+        const outcome = yield* loop.tick(handle)
+        const status = yield* loop.status(handle).pipe(Effect.catchCause(() => Effect.succeed(null)))
+        if (status) yield* ports.onStatus(status).pipe(Effect.catchCause(() => Effect.void))
+        if (outcome === "continue") return "continue" as const
+        return "terminal" as const
+      })
 
       // The post-tick durable cursor is the next command identity and the retry checkpoint for this command.
-      // If state vanished, runOneTick cannot continue, so the fallback is unused by the consumer.
+      // If state vanished, the tick cannot continue, so the fallback is unused by the consumer.
       const cursor = readGoalTickCursor(store, sessionID, request.goalId)
       const nextSeq = cursor?.seq ?? request.seq + 1
       const nextExpectedPlanVersion = cursor?.planVersion ?? request.expectedPlanVersion
 
-      return { progress: result.progress, nextSeq, nextExpectedPlanVersion }
+      return { progress, nextSeq, nextExpectedPlanVersion }
     }).pipe(
       // The port lives on `never` — a defect here (unexpected) must NOT crash the consumer's stream. But we
       // WANT a genuine transient failure to nack for retry, so we RE-RAISE as a die: the consumer's

packages/deepagent-code/src/session/multi-agent-runtime.ts

@@ -112,11 +112,7 @@ export interface LayerOptions {
     event: DeepAgentEvent.Event,
     files: ReadonlyArray<string>,
   ) => Effect.Effect<ReadonlyArray<string>>
-  //   §E2 token budget — injectable clock for the per-agent-per-hour LLM token budget's fixed window.
-  //   Defaults to Date.now; tests inject a mutable clock to cross the window boundary deterministically.
   readonly now?: () => number
-  //   §E2 token budget window (ms). Defaults to 1 hour — the §E2 "max_tokens_per_hour" cadence.
-  readonly tokenBudgetWindowMs?: number
 }
 
 export const layerWith = (options: LayerOptions) =>
@@ -131,29 +127,6 @@ export const layerWith = (options: LayerOptions) =>
       const symbolsForFiles = options.symbolsForFiles
       const runner = options.runner
       const now = options.now ?? Date.now
-      const tokenBudgetWindowMs = options.tokenBudgetWindowMs ?? 3_600_000 // 1h — §E2 max_tokens_per_hour
-      // §E2 LLM token budget — a per-agent fixed-window token accumulator (agentID → {windowStart, used}).
-      // A subtask is admitted only if the agent is not ALREADY over its declared maxTokensPerHour; after a
-      // turn we DEBIT the runner's reported tokensUsed. In-memory + process-local (mirrors the bus's
-      // publishLimiter): a single runtime instance owns it. P4.1 — the production event turn runner now
-      // threads the REAL per-turn token total (input+output+reasoning) from the prompt result, so this
-      // budget is LIVE: an agent over maxTokensPerHour genuinely defers. (A stub runner that reports 0 is
-      // still a harmless no-op debit — the tracker + enforcement are real either way.)
-      const tokenUsage = new Map<string, { windowStart: number; used: number }>()
-      const tokensUsedThisHour = (agentID: string, at: number): number => {
-        const bucket = tokenUsage.get(agentID)
-        if (!bucket || at - bucket.windowStart >= tokenBudgetWindowMs) return 0
-        return bucket.used
-      }
-      const debitTokens = (agentID: string, tokens: number, at: number): void => {
-        if (tokens <= 0) return
-        const bucket = tokenUsage.get(agentID)
-        if (!bucket || at - bucket.windowStart >= tokenBudgetWindowMs) {
-          tokenUsage.set(agentID, { windowStart: at, used: tokens })
-        } else {
-          bucket.used += tokens
-        }
-      }
       const trustedSources = options.trustedSources
       const trustedSourcesFor = options.trustedSourcesFor
       const actorHasPermission = options.actorHasPermission ?? (() => Effect.succeed(true))
@@ -294,19 +267,6 @@ export const layerWith = (options: LayerOptions) =>
               continue
             }
 
-            // §C1 max_files_changed — the agent's declared per-subtask file-scope ceiling. A subtask
-            // whose declared write scope exceeds it is BLOCKED (terminal, not deferred): the partition's
-            // fileScope is fixed, so a retry would present the SAME oversized scope — blocking is the
-            // honest outcome (deferring would spin forever). Unset ⇒ no ceiling. Checked right after the
-            // bind (it is an agent-vs-subtask fact) and before the autonomy/security gates.
-            const maxFilesChanged = agent.limits?.maxFilesChanged
-            if (maxFilesChanged != null && maxFilesChanged >= 0 && subtask.fileScope.length > maxFilesChanged) {
-              outcomes.push({ taskID: subtask.id, capability: subtask.capability, status: "blocked", agentID: agent.id, reason: "max_files_changed" })
-              yield* emit(event, { type: "agent.task.blocked", taskID: subtask.id, reason: "max_files_changed" }, `coord:${subtask.id}:blocked`)
-              // terminal (retrying won't shrink the scope) — do NOT mark hasUnfinished.
-              continue
-            }
-
             // §D autonomy gate — the agent's ceiling vs the subtask's required level.
             const autonomy = AutonomyPolicy.decide({
               agentCeiling: AutonomyPolicy.resolveCeiling(agent),
@@ -389,18 +349,6 @@ export const layerWith = (options: LayerOptions) =>
                 continue
               }
             }
-            // §E2 LLM token budget — a per-agent-per-hour ceiling on tokens consumed. If the agent is
-            // ALREADY at/over its declared maxTokensPerHour, DEFER this subtask (retryable — the window
-            // rolls over, unlike max_files_changed which is terminal). Checked before acquiring a slot so
-            // there is nothing to release on defer. Only bites when a budget is declared AND the runner
-            // reports real usage (the event turn runner reports 0 today → this never trips there yet).
-            const maxTokensPerHour = agent.limits?.maxTokensPerHour
-            if (maxTokensPerHour != null && maxTokensPerHour >= 0 && tokensUsedThisHour(agent.id, now()) >= maxTokensPerHour) {
-              outcomes.push({ taskID: subtask.id, capability: subtask.capability, status: "deferred", agentID: agent.id, reason: "token_budget_exceeded" })
-              hasUnfinished = true
-              continue
-            }
-
             // §E2 concurrency cap — acquire a per-workspace execution slot. Over cap ⇒ DEFER (retryable
             // via the bus, not dropped), so a burst never runs more than the workspace's cap at once.
             const slot = concurrency ? yield* concurrency.acquire(event.workspaceID) : undefined
@@ -488,11 +436,6 @@ export const layerWith = (options: LayerOptions) =>
                 }),
               ),
             )
-            // §E2 — DEBIT the tokens this turn actually consumed against the agent's per-hour budget, so
-            // the NEXT subtask this pass (and future events within the window) see the running total. P4.1 —
-            // the event turn runner now reports the real total, so this debit is live (a stub runner that
-            // reports 0 is simply a no-op debit).
-            debitTokens(agent.id, result.tokensUsed, now())
 
             if (result.ok) {
               outcomes.push({ taskID: subtask.id, capability: subtask.capability, status: "completed", agentID: agent.id })

packages/deepagent-code/src/session/v4-event-runtime.ts

@@ -39,7 +39,6 @@ import { GoalTickConsumer } from "./goal-tick-consumer"
 import { GoalTickPort } from "./goal-tick-port"
 import { goalStoreRoot } from "./goal-manager"
 import { SessionRevert } from "./revert"
-import { SessionSteer } from "./steer"
 import { EventV2Bridge } from "@/event-v2-bridge"
 // §C3 (P2.9) — file locks + code-graph symbols.
 import { FileLock } from "@deepagent-code/core/file-lock"
@@ -697,8 +696,8 @@ const panelConsumerLayer = Layer.unwrap(
 // makes the goal-loop tick GENUINELY event-driven with cross-process cold recovery: a goal survives a
 // process restart because every tick rebuilds its wiring from the durable run_context doc + the event
 // payload (no in-memory control map needed). Draws the SAME session stack makeEventTurnRunner uses, plus
-// SessionRevert / SessionSteer / LSP / EventV2Bridge for the rollback / goal-steer / diagnostics / SSE
-// ports, all from the shared graph.
+// SessionRevert / LSP / EventV2Bridge for the rollback / diagnostics / SSE ports, all from the shared
+// graph.
 //
 // FLAG COUPLING: runLoop = v4MultiAgentRuntime (the master event-driven switch — the goal-manager's
 // dual-path start publishes the FIRST command only on this flag). Default posture matches the flag: with
@@ -711,7 +710,6 @@ const goalTickConsumerLayer = Layer.unwrap(
     const agents = yield* Agent.Service
     const sessionPrompt = yield* SessionPrompt.Service
     const revert = yield* SessionRevert.Service
-    const steerBuffer = yield* SessionSteer.Service
     const provider = yield* Provider.Service
     const lsp = yield* LSP.Service
     const instanceStore = yield* InstanceStore.Service
@@ -723,7 +721,6 @@ const goalTickConsumerLayer = Layer.unwrap(
       agents,
       sessionPrompt,
       revert,
-      steerBuffer,
       provider,
       lsp,
       instanceStore,