@swarmclawai/swarmclaw 1.2.3 → 1.2.5

package/src/lib/server/chat-execution/prompt-builder.test.ts

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildAgenticExecutionPolicy } from '@/lib/server/chat-execution/prompt-builder'
+
+describe('buildAgenticExecutionPolicy', () => {
+  it('adds a routing matrix that teaches session introspection, durable tracking, and direct routing', () => {
+    const prompt = buildAgenticExecutionPolicy({
+      enabledExtensions: ['memory', 'manage_sessions', 'manage_tasks', 'manage_skills', 'spawn_subagent'],
+      loopMode: 'bounded',
+      heartbeatPrompt: 'HEARTBEAT',
+      heartbeatIntervalSec: 120,
+      userMessage: 'Figure out what tools you have, then continue the task.',
+      history: [],
+      mode: 'minimal',
+    })
+
+    assert.ok(prompt.includes('## Routing Matrix'))
+    assert.ok(prompt.includes('Current-thread facts already visible in this chat'))
+    assert.ok(prompt.includes('`memory_search`'))
+    assert.ok(prompt.includes('`sessions_tool` action `identity`'))
+    assert.ok(prompt.includes('`sessions_tool` action `history`'))
+    assert.ok(prompt.includes('`manage_tasks`'))
+    assert.ok(prompt.includes('`manage_skills`'))
+    assert.ok(prompt.includes('delegate or spawn a subagent'))
+    assert.ok(prompt.includes('use the concrete tool now'))
+    assert.ok(prompt.includes('prefer the direct `manage_*` tool'))
+  })
+})

package/src/lib/server/chat-execution/prompt-builder.ts

@@ -202,10 +202,11 @@ export function shouldForceAttachmentFollowthrough(params: {
   enabledExtensions: string[]
   hasToolCalls: boolean
   hasAttachmentContext: boolean
+  classification?: MessageClassification | null
 }): boolean {
   if (!params.hasAttachmentContext) return false
   if (params.hasToolCalls) return false
-  const decision = routeTaskIntent(params.userMessage, params.enabledExtensions, null)
+  const decision = routeTaskIntent(params.userMessage, params.enabledExtensions, null, params.classification ?? null)
   if (decision.intent !== 'research' && decision.intent !== 'browsing') return false
   return decision.preferredTools.some((toolName) => extensionIdMatches(params.enabledExtensions, toolName))
 }
@@ -326,6 +327,13 @@ export function buildAgenticExecutionPolicy(opts: {
   const extensionLines = isMinimal ? [] : buildExtensionCapabilityLines(opts.enabledExtensions, { delegationEnabled: opts.delegationEnabled, agentId: opts.agentId })
   const toolDisciplineLines = buildToolSection(opts.enabledExtensions)
   const hasMemoryTools = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'memory')
+  const hasManageSessions = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_sessions')
+  const hasManageTasks = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_tasks')
+  const hasManageSkills = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_skills')
+  const hasDelegationTools = opts.enabledExtensions.some((toolId) => {
+    const canonical = canonicalizeExtensionId(toolId) || toolId
+    return canonical === 'delegate' || canonical === 'spawn_subagent'
+  })
 
   const parts: string[] = []
 
@@ -351,6 +359,33 @@ export function buildAgenticExecutionPolicy(opts: {
       : 'Loop: BOUNDED — execute multiple steps but finish within recursion budget.',
   )
 
+  if (hasTooling) {
+    parts.push(
+      '## Routing Matrix',
+      'Current-thread facts already visible in this chat: answer directly from the thread before using tools.',
+      hasMemoryTools
+        ? 'Facts from previous conversations: start with `memory_search`, then `memory_get` only for a targeted follow-up read.'
+        : 'Facts from previous conversations: rely on the visible thread only and state when memory tools are unavailable.',
+      hasManageSessions
+        ? 'Harness/session context, lineage, project attachment, or enabled-tool questions: use `sessions_tool` action `identity`.'
+        : 'Harness/session introspection is limited here; rely on the runtime orientation block and visible context.',
+      hasManageSessions
+        ? 'Earlier messages from this same session that are not already visible in the thread: use `sessions_tool` action `history`.'
+        : 'Do not claim hidden session history is checked when `sessions_tool` is unavailable.',
+      hasManageTasks
+        ? 'Durable backlog or resumable progress tracking: use `manage_tasks` for multi-turn work, delegation, or explicit task-board requests.'
+        : 'Do not create pseudo-task workflows in prose when task tooling is unavailable.',
+      hasManageSkills
+        ? 'Missing capability, workflow, or environment setup blocker: use `manage_skills` before repeating generic exploration.'
+        : 'If a capability is genuinely missing, say so plainly instead of pretending a skill install happened.',
+      hasDelegationTools
+        ? 'Multi-step specialist work: delegate or spawn a subagent instead of doing the whole chain yourself.'
+        : 'If delegation tools are unavailable, execute directly with the tools you do have.',
+      'For direct reversible execution, use the concrete tool now instead of creating a task or stopping at advice.',
+      'When both `manage_platform` and a direct `manage_*` tool are available, prefer the direct `manage_*` tool.',
+    )
+  }
+
   // Sections skipped in minimal mode
   if (!isMinimal) {
     if (hasMemoryTools) {
@@ -374,7 +409,7 @@ export function buildAgenticExecutionPolicy(opts: {
         'Prefer `use_skill` action `run` for executable skills and `use_skill` action `load` only when the skill is guidance-only.',
       )
     }
-    if (opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_skills')) {
+    if (hasManageSkills) {
       parts.push(
         '## Skill Resolution',
         'When you are blocked on a missing capability, binary, or environment setup, call `manage_skills` before repeating generic exploration.',

package/src/lib/server/chat-execution/prompt-sections.test.ts

@@ -1,5 +1,8 @@
 import assert from 'node:assert/strict'
 import { after, before, describe, it } from 'node:test'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 
 let mod: typeof import('@/lib/server/chat-execution/prompt-sections')
 
@@ -86,6 +89,59 @@ describe('prompt-sections', () => {
     })
   })
 
+  describe('buildRuntimeOrientationSection', () => {
+    it('includes delegated lineage, workspace markers, project context, and routing guidance', () => {
+      const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-runtime-orientation-'))
+      try {
+        fs.writeFileSync(path.join(cwd, 'AGENTS.md'), '# Agent notes')
+        const result = mod.buildRuntimeOrientationSection({
+          session: {
+            id: 'child-session',
+            cwd,
+            provider: 'openai',
+            model: 'gpt-5',
+            parentSessionId: 'parent-session',
+            agentId: 'agent-1',
+          } as never,
+          promptMode: 'minimal',
+          sessionExtensions: ['files', 'manage_sessions', 'codex_cli'],
+          toolPolicy: {
+            mode: 'balanced',
+            requestedExtensions: ['files', 'manage_sessions', 'codex_cli', 'manage_secrets'],
+            enabledExtensions: ['files', 'manage_sessions', 'codex_cli'],
+            blockedExtensions: [{ tool: 'manage_secrets', reason: 'blocked by policy', source: 'policy' }],
+          },
+          agent: {
+            id: 'agent-1',
+            name: 'Builder',
+            delegationTargetMode: 'selected',
+            delegationTargetAgentIds: ['qa-1', 'ops-1'],
+          } as never,
+          activeProjectContext: {
+            projectId: 'project-1',
+            project: { name: 'Northstar' },
+            projectRoot: '/workspace/projects/project-1',
+          } as never,
+          rootSessionId: 'root-session',
+        })
+
+        assert.ok(result.includes('## Runtime Orientation'))
+        assert.ok(result.includes('delegated_child'))
+        assert.ok(result.includes('prompt=minimal'))
+        assert.ok(result.includes('root=root-session'))
+        assert.ok(result.includes('Workspace markers: AGENTS.md'))
+        assert.ok(result.includes('Active project: Northstar'))
+        assert.ok(result.includes('`manage_sessions`'))
+        assert.ok(result.includes('`codex_cli`'))
+        assert.ok(result.includes('Policy blocked:'))
+        assert.ok(result.includes('sessions_tool'))
+        assert.ok(result.includes('use `manage_platform` only as fallback'))
+      } finally {
+        fs.rmSync(cwd, { recursive: true, force: true })
+      }
+    })
+  })
+
   // ---- buildProjectSection ----
   describe('buildProjectSection', () => {
     it('returns null for minimal mode', () => {

package/src/lib/server/chat-execution/prompt-sections.ts

@@ -6,13 +6,24 @@
  * The main prompt assembly in stream-agent-chat.ts composes these declaratively.
  */
 
+import fs from 'node:fs'
+import path from 'node:path'
 import type { Session, Agent } from '@/types'
+import type { PromptMode } from '@/lib/server/chat-execution/prompt-mode'
+import type { MessageClassification } from '@/lib/server/chat-execution/message-classifier'
 import type { ActiveProjectContext } from '@/lib/server/project-context'
+import type { SessionToolPolicyDecision } from '@/lib/server/tool-capability-policy'
 import { buildIdentityContinuityContext } from '@/lib/server/identity-continuity'
+import {
+  buildDelegationTaskProfile,
+  formatDelegationRationale,
+  resolveDelegationAdvisory,
+} from '@/lib/server/agents/delegation-advisory'
 import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
 import { loadSkills } from '@/lib/server/skills/skill-repository'
 import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 import { resolveTeam } from '@/lib/server/agents/team-resolution'
+import { canonicalizeExtensionId } from '@/lib/server/tool-aliases'
 
 // ---------------------------------------------------------------------------
 // Identity: agent name, description, continuity, soul, systemPrompt, skills
@@ -89,6 +100,148 @@ export function buildThinkingSection(
   return text ? `## Reasoning Depth\n${text}` : null
 }
 
+// ---------------------------------------------------------------------------
+// Runtime Orientation
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_MARKER_FILES = [
+  'AGENTS.md',
+  'BOOTSTRAP.md',
+  'HEARTBEAT.md',
+  'IDENTITY.md',
+  'TOOLS.md',
+  'USER.md',
+]
+
+function normalizeRuntimeExtensionId(extensionId: string): string {
+  const normalized = extensionId.trim().toLowerCase()
+  if (!normalized) return ''
+  if (normalized === 'delegate_to_claude_code' || normalized === 'claude_code') return 'claude_code'
+  if (normalized === 'delegate_to_codex_cli' || normalized === 'codex_cli') return 'codex_cli'
+  if (normalized === 'delegate_to_opencode_cli' || normalized === 'opencode_cli') return 'opencode_cli'
+  if (normalized === 'delegate_to_gemini_cli' || normalized === 'gemini_cli') return 'gemini_cli'
+  if (['session_info', 'sessions_tool', 'whoami_tool', 'search_history_tool'].includes(normalized)) return 'manage_sessions'
+  return canonicalizeExtensionId(normalized)
+}
+
+function canonicalizeEnabledExtensions(enabledExtensions: string[]): string[] {
+  const seen = new Set<string>()
+  const values: string[] = []
+  for (const extensionId of enabledExtensions) {
+    const normalized = normalizeRuntimeExtensionId(extensionId)
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    values.push(normalized)
+  }
+  return values
+}
+
+function formatInlineCodeList(values: string[], maxItems = 8): string {
+  if (values.length === 0) return '(none)'
+  const head = values.slice(0, maxItems).map((value) => `\`${value}\``)
+  if (values.length > maxItems) head.push(`... +${values.length - maxItems} more`)
+  return head.join(', ')
+}
+
+function formatPolicyBlocks(blocked: SessionToolPolicyDecision['blockedExtensions'], maxItems = 3): string {
+  const lines = blocked
+    .slice(0, maxItems)
+    .map((entry) => `\`${canonicalizeExtensionId(entry.tool)}\` (${entry.reason})`)
+  if (blocked.length > maxItems) lines.push(`... +${blocked.length - maxItems} more`)
+  return lines.join(', ')
+}
+
+function collectWorkspaceMarkers(cwd: string | null | undefined): string[] {
+  if (typeof cwd !== 'string' || !cwd.trim()) return []
+  return WORKSPACE_MARKER_FILES.filter((filename) => {
+    try {
+      return fs.existsSync(path.join(cwd, filename))
+    } catch {
+      return false
+    }
+  })
+}
+
+function resolveRuntimeSessionKind(params: {
+  session: Session
+  isHeartbeat?: boolean
+  isConnectorSession?: boolean
+}): string {
+  if (params.isHeartbeat) return 'heartbeat'
+  if (params.isConnectorSession) return 'connector'
+  if (params.session.parentSessionId) return 'delegated_child'
+  return 'root_chat'
+}
+
+export function buildRuntimeOrientationSection(params: {
+  session: Session
+  promptMode: PromptMode
+  sessionExtensions: string[]
+  toolPolicy?: SessionToolPolicyDecision | null
+  agent?: Agent | null
+  activeProjectContext?: ActiveProjectContext | null
+  rootSessionId?: string | null
+  isHeartbeat?: boolean
+  isConnectorSession?: boolean
+}): string {
+  const { session, agent } = params
+  const activeProjectContext = params.activeProjectContext || null
+  const enabledExtensions = canonicalizeEnabledExtensions(params.sessionExtensions)
+  const workspaceMarkers = collectWorkspaceMarkers(session.cwd)
+  const delegationEnabled = enabledExtensions.some((extensionId) =>
+    ['delegate', 'spawn_subagent', 'claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli'].includes(extensionId),
+  )
+
+  const lines = [
+    '## Runtime Orientation',
+    `Session: ${resolveRuntimeSessionKind({ session, isHeartbeat: params.isHeartbeat, isConnectorSession: params.isConnectorSession })} | prompt=${params.promptMode} | id=${session.id}`,
+    session.parentSessionId || params.rootSessionId
+      ? `Lineage: parent=${session.parentSessionId || '(none)'} | root=${params.rootSessionId || session.id}`
+      : `Lineage: root=${session.id}`,
+    `Agent: ${agent?.name || session.agentId || 'Unassigned'}${session.agentId ? ` [id: ${session.agentId}]` : ''}`,
+    `Provider/model: ${session.provider} / ${session.model || '(default)'}`,
+    `CWD: ${session.cwd || '(none)'}`,
+  ]
+
+  if (workspaceMarkers.length > 0) {
+    lines.push(`Workspace markers: ${workspaceMarkers.join(', ')}`)
+  }
+
+  if (activeProjectContext?.projectId) {
+    const projectLabel = activeProjectContext.project?.name || activeProjectContext.projectId
+    const projectRoot = activeProjectContext.projectRoot ? ` | root=${activeProjectContext.projectRoot}` : ''
+    lines.push(`Active project: ${projectLabel}${projectRoot}`)
+  }
+
+  lines.push(`Enabled capabilities now: ${formatInlineCodeList(enabledExtensions)}`)
+
+  if (params.toolPolicy?.blockedExtensions?.length) {
+    lines.push(`Policy blocked: ${formatPolicyBlocks(params.toolPolicy.blockedExtensions)}`)
+  }
+
+  if (delegationEnabled) {
+    const delegateMode = agent?.delegationTargetMode === 'selected' ? 'selected' : 'all'
+    const targetIds = Array.isArray(agent?.delegationTargetAgentIds)
+      ? agent!.delegationTargetAgentIds.filter((value) => typeof value === 'string' && value.trim())
+      : []
+    lines.push(
+      delegateMode === 'selected'
+        ? `Delegation: enabled (${delegateMode}) | targets=${targetIds.length ? targetIds.join(', ') : '(none configured)'}`
+        : 'Delegation: enabled (all allowed targets)',
+    )
+  } else {
+    lines.push('Delegation: disabled in this runtime')
+  }
+
+  if (enabledExtensions.includes('manage_sessions')) {
+    lines.push('Harness inspection: use `sessions_tool` action `identity` for live session/platform context; use action `history` only when you need earlier messages from this same session.')
+  }
+
+  lines.push('Platform routing: prefer direct `manage_*` tools when enabled; use `manage_platform` only as fallback.')
+
+  return lines.join('\n')
+}
+
 // ---------------------------------------------------------------------------
 // Workspace Context (async — dynamic import)
 // ---------------------------------------------------------------------------
@@ -414,6 +567,43 @@ export function buildCoordinatorSection(
   return lines.join('\n')
 }
 
+export function buildDelegationRecommendationSection(params: {
+  agent: Agent | null | undefined
+  classification?: MessageClassification | null
+}): string | null {
+  const agent = params.agent
+  if (!agent || agent.delegationEnabled !== true) return null
+  const profile = buildDelegationTaskProfile({
+    classification: params.classification,
+  })
+  if (!profile.substantial) return null
+
+  const advisory = resolveDelegationAdvisory({
+    currentAgent: agent,
+    agents: listAgents(),
+    profile,
+    delegationTargetMode: agent.delegationTargetMode === 'selected' ? 'selected' : 'all',
+    delegationTargetAgentIds: agent.delegationTargetAgentIds || [],
+  })
+  if (!advisory.shouldDelegate || !advisory.recommended) return null
+
+  const recommendation = advisory.recommended
+  const workLabel = profile.workType === 'general' ? 'substantial work' : `${profile.workType} work`
+  const recommendationLabel = advisory.style === 'managerial'
+    ? 'Managerial Delegation Recommendation'
+    : 'Delegation Recommendation'
+
+  return [
+    `## ${recommendationLabel}`,
+    `This request looks like ${workLabel}.`,
+    `Best-fit teammate: **${recommendation.agentName}** [id: ${recommendation.agentId}]`,
+    `Why: ${formatDelegationRationale(recommendation)}.`,
+    advisory.style === 'managerial'
+      ? 'Prefer delegating the execution and keep your direct work to reconnaissance, validation, and synthesis.'
+      : 'Prefer delegating the execution and reserve direct tool use for quick lookups or validation.',
+  ].join('\n')
+}
+
 // ---------------------------------------------------------------------------
 // Credential Awareness
 // ---------------------------------------------------------------------------
@@ -527,3 +717,6 @@ export function buildCliDelegationContext(opts: {
 
   return parts.join('\n')
 }
+
+// Re-export RunContext prompt builder from its canonical home
+export { buildRunContextSection } from '@/lib/server/run-context'

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -3,7 +3,7 @@ import { HumanMessage, AIMessage } from '@langchain/core/messages'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
 import { MemorySaver } from '@langchain/langgraph'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
-import { getAgent } from '@/lib/server/agents/agent-repository'
+import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { buildChatModel } from '@/lib/server/build-llm'
 import { loadSettings } from '@/lib/server/settings/settings-repository'
@@ -18,6 +18,7 @@ import { truncateToolResultText } from '@/lib/server/chat-execution/tool-result-
 import {
   buildIdentitySection,
   buildThinkingSection,
+  buildRuntimeOrientationSection,
   buildWorkspaceSection,
   buildAgentAwarenessSection,
   buildSituationalSection,
@@ -27,13 +28,15 @@ import {
   buildProactiveMemorySection,
   buildCoordinatorSection,
   buildCredentialAwarenessSection,
+  buildDelegationRecommendationSection,
+  buildRunContextSection,
 } from '@/lib/server/chat-execution/prompt-sections'
 
 import { log } from '@/lib/server/logger'
 import { logExecution } from '@/lib/server/execution-log'
 import { buildCurrentDateTimePromptContext } from '@/lib/server/prompt-runtime-context'
 import { expandExtensionIds } from '@/lib/server/tool-aliases'
-import type { Session, Message } from '@/types'
+import type { ExecutionBrief, Session, Message } from '@/types'
 import { getEnabledCapabilityIds } from '@/lib/capability-selection'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { resolveActiveProjectContext } from '@/lib/server/project-context'
@@ -89,6 +92,7 @@ import {
   DEFAULT_PROMPT_BUDGET,
   MINIMAL_PROMPT_BUDGET,
 } from '@/lib/server/chat-execution/prompt-budget'
+import { resolveSessionLineageIds } from '@/lib/server/sessions/session-lineage'
 import { IterationTimers } from '@/lib/server/chat-execution/iteration-timers'
 import { processIterationEvents } from '@/lib/server/chat-execution/iteration-event-handler'
 import { evaluateContinuation } from '@/lib/server/chat-execution/continuation-evaluator'
@@ -101,6 +105,11 @@ import {
   isResearchSynthesis as classifiedIsResearchSynthesis,
   type MessageClassification,
 } from '@/lib/server/chat-execution/message-classifier'
+import {
+  buildDelegationTaskProfile,
+  formatDelegationRationale,
+  resolveDelegationAdvisory,
+} from '@/lib/server/agents/delegation-advisory'
 
 const TAG = 'stream-agent-chat'
 
@@ -174,6 +183,7 @@ interface StreamAgentChatOpts {
   attachedFiles?: string[]
   apiKey: string | null
   systemPrompt?: string
+  executionBrief?: ExecutionBrief | null
   extraSystemContext?: string[]
   write: (data: string) => void
   history: Message[]
@@ -213,7 +223,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
 async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
   const startTs = Date.now()
-  const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
+  const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, executionBrief, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
   const isHeartbeat = isHeartbeatSource(opts.source)
   const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session)
   const isMinimalPrompt = promptMode === 'minimal'
@@ -221,7 +231,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const rawExtensions = getEnabledCapabilityIds(session)
   const hasShellCapability = rawExtensions.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
   const extensionManager = getExtensionManager()
-  const sessionExtensions = expandExtensionIds([
+  const requestedExtensions = expandExtensionIds([
     ...rawExtensions,
     ...(hasShellCapability ? ['process'] : []),
   ]).filter((id) => !extensionManager.isExplicitlyDisabled(id))
@@ -249,10 +259,15 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Build agent prompt
   const settings = loadSettings()
+  const toolPolicy = resolveSessionToolPolicy(requestedExtensions, settings)
+  const blockedExtensionIds = new Set(expandExtensionIds(toolPolicy.blockedExtensions.map((entry) => entry.tool)))
+  const sessionExtensions = expandExtensionIds(toolPolicy.enabledExtensions)
+    .filter((id) => !blockedExtensionIds.has(id))
+    .filter((id) => !extensionManager.isExplicitlyDisabled(id))
   const requestedToolPreflightResponse = resolveRequestedToolPreflightResponse({
     message,
     enabledExtensions: sessionExtensions,
-    toolPolicy: resolveSessionToolPolicy(sessionExtensions, settings),
+    toolPolicy,
     appSettings: settings,
     internal: false,
     source: 'chat',
@@ -296,6 +311,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // -------------------------------------------------------------------------
   const promptParts: string[] = []
   const hasProvidedSystemPrompt = typeof systemPrompt === 'string' && systemPrompt.trim().length > 0
+  const hasCanonicalExecutionBrief = Boolean(executionBrief)
   const currentThreadRecallRequest = isCurrentThreadRecallRequest(message)
   const hasAttachmentContext = Boolean(
     imagePath
@@ -347,18 +363,37 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // Composable prompt sections — each builder returns string | null (or string[])
   const thinkingBlock = buildThinkingSection(agentThinkingLevel, isMinimalPrompt)
   if (thinkingBlock) promptParts.push(thinkingBlock)
+  const { rootSessionId } = resolveSessionLineageIds(session)
 
   // Async sections — run concurrently where possible
-  const [workspaceBlock, awarenessBlock, situationalBlock, extensionAuditBlock] = await Promise.all([
+  const [runtimeOrientationBlock, workspaceBlock, awarenessBlock, situationalBlock, extensionAuditBlock] = await Promise.all([
+    buildRuntimeOrientationSection({
+      session,
+      promptMode,
+      sessionExtensions,
+      toolPolicy,
+      agent: sessionAgent,
+      activeProjectContext,
+      rootSessionId,
+      isHeartbeat,
+      isConnectorSession,
+    }),
     !hasProvidedSystemPrompt ? buildWorkspaceSection(session, isMinimalPrompt, agentHeartbeatEnabled) : null,
     buildAgentAwarenessSection(session, sessionExtensions, isMinimalPrompt),
     buildSituationalSection(session, isMinimalPrompt),
     buildExtensionAccessAuditSection(sessionExtensions, agentMcpDisabledTools, isMinimalPrompt),
   ])
+  if (runtimeOrientationBlock) promptParts.push(runtimeOrientationBlock)
   if (workspaceBlock) promptParts.push(workspaceBlock)
   if (awarenessBlock) promptParts.push(awarenessBlock)
   if (situationalBlock) promptParts.push(situationalBlock)
 
+  // RunContext — structured working memory that survives compaction
+  if (!hasProvidedSystemPrompt && !hasCanonicalExecutionBrief) {
+    const runContextBlock = buildRunContextSection(session.runContext, isMinimalPrompt)
+    if (runContextBlock) promptParts.push(runContextBlock)
+  }
+
   // Extra system context — always included (caller-provided context is always relevant)
   if (Array.isArray(extraSystemContext)) {
     for (const block of extraSystemContext) {
@@ -393,6 +428,22 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Await classification before building the agentic execution policy
   const classification = await classificationPromise
+  const delegationAdvisory = sessionAgent && agentDelegationEnabled
+    ? resolveDelegationAdvisory({
+        currentAgent: sessionAgent,
+        agents: listAgents(),
+        profile: buildDelegationTaskProfile({ classification }),
+        delegationTargetMode: agentDelegationTargetMode,
+        delegationTargetAgentIds: agentDelegationTargetAgentIds,
+      })
+    : null
+  const delegationRecommendationBlock = !isMinimalPrompt
+    ? buildDelegationRecommendationSection({
+        agent: sessionAgent,
+        classification,
+      })
+    : null
+  if (delegationRecommendationBlock) promptParts.push(delegationRecommendationBlock)
 
   promptParts.push(
     buildAgenticExecutionPolicy({
@@ -813,7 +864,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // -------------------------------------------------------------------------
   const state = new ChatTurnState()
   const limits = new ContinuationLimits(isConnectorSession, isHeartbeat)
-  const routingDecision = routeTaskIntent(message, sessionExtensions, null)
+  const routingDecision = routeTaskIntent(message, sessionExtensions, null, classification)
   const explicitRequiredToolNames = getExplicitRequiredToolNames(message, sessionExtensions)
 
   const boundedExternalExecutionTask = classifiedHasTransactionalWalletIntent(classification, message)
@@ -1071,6 +1122,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
           likelyResearchSynthesisTask,
           abortControllerAborted: abortController.signal.aborted,
           classification,
+          delegationEnabled: agentDelegationEnabled,
+          delegationPreferenceActive: delegationAdvisory?.shouldDelegate === true,
         })
         shouldContinue = decision.type
         if (decision.requiredToolReminderNames.length > 0) {
@@ -1123,6 +1176,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         cwd: session.cwd,
         frequencyLimitedToolName,
         sessionExtensions,
+        isCoordinatorAgent,
+        recommendedDelegateName: delegationAdvisory?.recommended?.agentName || null,
+        delegationRationale: formatDelegationRationale(delegationAdvisory?.recommended),
       })
 
       if (continuationPrompt) {

package/src/lib/server/chat-execution/stream-continuation.test.ts

@@ -290,5 +290,41 @@ describe('stream-continuation', () => {
       assert.equal(typeof prompt, 'string')
       assert.ok(prompt!.includes('memory write'))
     })
+
+    it('renders a coordinator delegation nudge with the recommended delegate', () => {
+      const prompt = mod.buildContinuationPrompt({
+        type: 'coordinator_delegation_nudge',
+        message: 'test',
+        fullText: '',
+        toolEvents: [],
+        requiredToolReminderNames: [],
+        isCoordinatorAgent: true,
+        recommendedDelegateName: 'Builder',
+        delegationRationale: 'capability match: coding; worker role fits execution-heavy work',
+      })
+
+      assert.ok(prompt)
+      assert.ok(prompt!.includes('Builder'))
+      assert.ok(prompt!.includes('orchestrate'))
+      assert.ok(prompt!.includes('Reason: capability match: coding; worker role fits execution-heavy work.'))
+    })
+
+    it('renders an advisory delegation nudge for non-coordinator agents', () => {
+      const prompt = mod.buildContinuationPrompt({
+        type: 'coordinator_delegation_nudge',
+        message: 'test',
+        fullText: '',
+        toolEvents: [],
+        requiredToolReminderNames: [],
+        isCoordinatorAgent: false,
+        recommendedDelegateName: 'Reviewer',
+        delegationRationale: 'capability match: review; currently idle',
+      })
+
+      assert.ok(prompt)
+      assert.ok(prompt!.includes('materially better fit'))
+      assert.ok(prompt!.includes('Reviewer'))
+      assert.ok(prompt!.includes('reconnaissance, validation, or synthesis'))
+    })
   })
 })