@swarmclawai/swarmclaw 1.9.13 → 1.9.14

package/README.md

@@ -399,6 +399,15 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.14 Highlights
+
+Session context-pack release: SwarmClaw now turns a live chat into a concise handoff packet with session metadata, recent visible turns, linked tasks, attachments, resume handles, and next actions.
+
+- **Context-pack API.** `GET /api/chats/:id/context-pack` returns structured handoff JSON, and `?format=markdown` returns copyable markdown.
+- **Chat header copy action.** Active chats with messages expose a context-pack button for quick handoff to another operator or backend.
+- **CLI access.** `swarmclaw chats context-pack <chatId> --query format=markdown` exposes the same packet for scripts and release automation.
+- **Smoke coverage.** Runtime tests and the browser smoke gate now verify the context-pack route and markdown response.
+
 ### v1.9.13 Highlights
 
 Architecture health release: SwarmClaw now turns runtime ownership, dispatch, memory, startup, and quality evidence into a scored operator report.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.13",
+  "version": "1.9.14",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",
@@ -88,7 +88,7 @@
     "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/electron-after-pack.test.mjs scripts/ensure-sandbox-browser-image.test.mjs scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
     "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts src/lib/server/storage-auth.test.ts src/lib/server/storage-auth-docker.test.ts",
     "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/connectors/swarmdock.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/gateways/gateway-topology.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/session-tools/swarmdock.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openai.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/gateways/topology-route.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
-    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/provider-sets.test.ts src/lib/providers/opencode-cli.test.ts src/lib/providers/cli-provider-metadata.test.ts src/lib/providers/cli-utils.test.ts src/lib/providers/generic-cli.test.ts src/lib/server/agents/delegation-advisory.test.ts src/lib/server/cli-provider-readiness.test.ts src/lib/server/provider-health.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/extension-managed-resources.test.ts src/lib/server/eval/baseline.test.ts src/lib/server/eval/environment-plan.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/runtime/queue-retry-policy.test.ts src/lib/server/runs/run-brief.test.ts src/lib/server/operations/operation-pulse.test.ts src/lib/server/schedules/schedule-history.test.ts src/lib/quality/release-readiness.test.ts src/lib/quality/architecture-health.test.ts src/lib/server/artifacts/artifact-resolver.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/server/sharing/share-link-repository.test.ts src/lib/server/sharing/share-resolver.test.ts src/lib/server/tasks/task-execution-workspace.test.ts src/lib/server/tasks/task-execution-policy.test.ts src/lib/server/tasks/task-handoff.test.ts src/lib/server/tasks/task-service.test.ts src/lib/server/session-tools/execute.test.ts src/lib/server/session-tools/manage-tasks.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/tasks/task-workspace-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/extensions/managed-resources/route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/portability/export/route.test.ts src/app/api/portability/import/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/schedules/schedule-history-route.test.ts src/app/api/tts/route.test.ts",
+    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/provider-sets.test.ts src/lib/providers/opencode-cli.test.ts src/lib/providers/cli-provider-metadata.test.ts src/lib/providers/cli-utils.test.ts src/lib/providers/generic-cli.test.ts src/lib/server/agents/delegation-advisory.test.ts src/lib/server/cli-provider-readiness.test.ts src/lib/server/provider-health.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/extension-managed-resources.test.ts src/lib/server/eval/baseline.test.ts src/lib/server/eval/environment-plan.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/chats/session-context-pack.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/runtime/queue-retry-policy.test.ts src/lib/server/runs/run-brief.test.ts src/lib/server/operations/operation-pulse.test.ts src/lib/server/schedules/schedule-history.test.ts src/lib/quality/release-readiness.test.ts src/lib/quality/architecture-health.test.ts src/lib/server/artifacts/artifact-resolver.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/server/sharing/share-link-repository.test.ts src/lib/server/sharing/share-resolver.test.ts src/lib/server/tasks/task-execution-workspace.test.ts src/lib/server/tasks/task-execution-policy.test.ts src/lib/server/tasks/task-handoff.test.ts src/lib/server/tasks/task-service.test.ts src/lib/server/session-tools/execute.test.ts src/lib/server/session-tools/manage-tasks.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/tasks/task-workspace-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-pack-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/extensions/managed-resources/route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/portability/export/route.test.ts src/app/api/portability/import/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/schedules/schedule-history-route.test.ts src/app/api/tts/route.test.ts",
     "test:builder": "tsx --test src/features/protocols/builder/utils/nodes-to-template.test.ts src/features/protocols/builder/utils/template-to-nodes.test.ts src/features/protocols/builder/validators/dag-validator.test.ts",
     "test:e2e": "node --import tsx scripts/browser-e2e-smoke.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",

package/src/app/api/chats/[id]/context-pack/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server'
+
+import { buildSessionContextPack, formatSessionContextPackMarkdown } from '@/lib/server/chats/session-context-pack'
+import { notFound } from '@/lib/server/collection-helpers'
+import { getMessages } from '@/lib/server/messages/message-repository'
+import { getSession } from '@/lib/server/sessions/session-repository'
+import { listTasks } from '@/lib/server/tasks/task-repository'
+
+const DEFAULT_RECENT_MESSAGES = 12
+const MAX_RECENT_MESSAGES = 40
+
+function parseMaxRecentMessages(req: Request): number {
+  const url = new URL(req.url)
+  const raw = url.searchParams.get('messages') || url.searchParams.get('maxRecentMessages')
+  const parsed = Number.parseInt(raw || '', 10)
+  if (!Number.isFinite(parsed)) return DEFAULT_RECENT_MESSAGES
+  return Math.max(1, Math.min(MAX_RECENT_MESSAGES, parsed))
+}
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const session = getSession(id)
+  if (!session) return notFound()
+
+  const url = new URL(req.url)
+  const format = url.searchParams.get('format')
+  const pack = buildSessionContextPack({
+    session,
+    messages: getMessages(id),
+    tasks: listTasks(),
+    maxRecentMessages: parseMaxRecentMessages(req),
+  })
+
+  if (format === 'markdown') {
+    return new Response(formatSessionContextPackMarkdown(pack), {
+      headers: {
+        'content-type': 'text/markdown; charset=utf-8',
+      },
+    })
+  }
+
+  return NextResponse.json(pack)
+}

package/src/app/api/chats/context-pack-route.test.ts

@@ -0,0 +1,109 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('GET /api/chats/[id]/context-pack returns structured and markdown handoff context', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    markdownStatus: number
+    missingStatus: number
+    schemaVersion: number
+    linkedTaskCount: number
+    recentMessageCount: number
+    markdownContentType: string
+    markdownIncludesTitle: boolean
+    markdownIncludesTask: boolean
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const routeMod = await import('./src/app/api/chats/[id]/context-pack/route')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
+
+    const now = Date.now()
+    storage.saveSessions({
+      sess_pack_1: {
+        id: 'sess_pack_1',
+        name: 'Context pack test',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-4o-mini',
+        claudeSessionId: null,
+        codexThreadId: 'codex-pack-thread',
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+        runContext: {
+          objective: 'Hand off a release session.',
+          constraints: ['Keep the pack short.'],
+          keyFacts: ['The current tag is local only.'],
+          discoveries: [],
+          failedApproaches: [],
+          currentPlan: ['Run checks'],
+          completedSteps: [],
+          blockers: [],
+          parentContext: null,
+          updatedAt: now,
+          version: 1,
+        },
+      },
+    })
+    storage.saveTasks({
+      task_pack_1: {
+        id: 'task_pack_1',
+        title: 'Verify context pack',
+        description: 'Exercise API route.',
+        status: 'running',
+        sessionId: 'sess_pack_1',
+        agentId: null,
+        createdAt: now,
+        updatedAt: now + 3,
+      },
+    })
+
+    repo.appendMessage('sess_pack_1', { role: 'user', text: 'Prepare handoff.', time: now, attachedFiles: ['/tmp/handoff.md'] })
+    repo.appendMessage('sess_pack_1', { role: 'assistant', text: 'Ready.', time: now + 1 })
+
+    const response = await route.GET(
+      new Request('http://local/api/chats/sess_pack_1/context-pack?messages=1'),
+      { params: Promise.resolve({ id: 'sess_pack_1' }) },
+    )
+    const payload = await response.json()
+
+    const markdownResponse = await route.GET(
+      new Request('http://local/api/chats/sess_pack_1/context-pack?format=markdown'),
+      { params: Promise.resolve({ id: 'sess_pack_1' }) },
+    )
+    const markdown = await markdownResponse.text()
+
+    const missingResponse = await route.GET(
+      new Request('http://local/api/chats/missing/context-pack'),
+      { params: Promise.resolve({ id: 'missing' }) },
+    )
+
+    console.log(JSON.stringify({
+      status: response.status,
+      markdownStatus: markdownResponse.status,
+      missingStatus: missingResponse.status,
+      schemaVersion: payload.schemaVersion,
+      linkedTaskCount: payload.linkedTasks.length,
+      recentMessageCount: payload.recentMessages.length,
+      markdownContentType: markdownResponse.headers.get('content-type') || '',
+      markdownIncludesTitle: markdown.includes('# Session Context Pack: Context pack test'),
+      markdownIncludesTask: markdown.includes('Verify context pack'),
+    }))
+  `, { prefix: 'swarmclaw-context-pack-route-' })
+
+  assert.equal(output.status, 200)
+  assert.equal(output.markdownStatus, 200)
+  assert.equal(output.missingStatus, 404)
+  assert.equal(output.schemaVersion, 1)
+  assert.equal(output.linkedTaskCount, 1)
+  assert.equal(output.recentMessageCount, 1)
+  assert.match(output.markdownContentType, /text\/markdown/)
+  assert.equal(output.markdownIncludesTitle, true)
+  assert.equal(output.markdownIncludesTask, true)
+})

package/src/cli/index.js

@@ -627,6 +627,7 @@ const COMMAND_GROUPS = [
       cmd('clear-undo', 'POST', '/chats/:id/clear/undo', 'Restore a cleared chat via its undoToken', { expectsJsonBody: true }),
       cmd('compact', 'POST', '/chats/:id/compact', 'Summarize and compact chat history (accepts optional keepLastN)', { expectsJsonBody: true }),
       cmd('context-status', 'GET', '/chats/:id/context-status', 'Report token usage and context-window status for a chat'),
+      cmd('context-pack', 'GET', '/chats/:id/context-pack', 'Get a copyable session context pack for handoff'),
       cmd('browser-status', 'GET', '/chats/:id/browser', 'Check browser status'),
       cmd('browser-close', 'DELETE', '/chats/:id/browser', 'Close browser'),
       cmd('mailbox', 'GET', '/chats/:id/mailbox', 'List chat mailbox envelopes'),

package/src/cli/spec.js

@@ -458,6 +458,7 @@ const COMMAND_GROUPS = {
       'clear-undo': { description: 'Restore a cleared chat via its undoToken', method: 'POST', path: '/chats/:id/clear/undo', params: ['id'] },
       compact: { description: 'Summarize and compact chat history', method: 'POST', path: '/chats/:id/compact', params: ['id'] },
       'context-status': { description: 'Report token usage and context-window status', method: 'GET', path: '/chats/:id/context-status', params: ['id'] },
+      'context-pack': { description: 'Get a copyable session context pack for handoff', method: 'GET', path: '/chats/:id/context-pack', params: ['id'] },
       mailbox: { description: 'List mailbox envelopes for a chat', method: 'GET', path: '/chats/:id/mailbox', params: ['id'] },
       'mailbox-action': { description: 'Send/ack/clear mailbox envelopes', method: 'POST', path: '/chats/:id/mailbox', params: ['id'] },
       queue: { description: 'List queued follow-up turns for a chat', method: 'GET', path: '/chats/:id/queue', params: ['id'] },

package/src/components/chat/chat-header.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { useEffect, useState, useMemo, useRef, type ReactNode } from 'react'
-import { Plus } from 'lucide-react'
+import { ClipboardList, Plus } from 'lucide-react'
 import type { Session } from '@/types'
 import { useAppStore } from '@/stores/use-app-store'
 import { useChatStore } from '@/stores/use-chat-store'
@@ -108,6 +108,8 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
   const connectorMeta = connector ? resolveConnectorPlatformMeta(connector.platform) : null
   const connectorPresence = connector?.presence
   const [copied, setCopied] = useState(false)
+  const [contextPackCopied, setContextPackCopied] = useState(false)
+  const [contextPackLoading, setContextPackLoading] = useState(false)
   const [sourceDropdownOpen, setSourceDropdownOpen] = useState(false)
   const sourceDropdownRef = useRef<HTMLDivElement>(null)
   const [renaming, setRenaming] = useState(false)
@@ -220,6 +222,22 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
     })
   }
 
+  const handleCopyContextPack = async () => {
+    if (contextPackLoading) return
+    setContextPackLoading(true)
+    try {
+      const markdown = await api<string>('GET', `/chats/${session.id}/context-pack?format=markdown`)
+      const copiedPack = await copyTextToClipboard(markdown)
+      if (!copiedPack) return
+      setContextPackCopied(true)
+      setTimeout(() => setContextPackCopied(false), 2000)
+    } catch {
+      // Best-effort clipboard helper; the route remains available from the CLI.
+    } finally {
+      setContextPackLoading(false)
+    }
+  }
+
   const handleDismissResumeHandle = async (e: React.MouseEvent) => {
     e.stopPropagation()
     try {
@@ -302,10 +320,11 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
     }
   }, [session.name, loadConnectors])
 
-  // Context bar shows for memories, source filter, task links, resume handles, browser
+  // Context bar shows for handoff packs, memories, source filter, task links, resume handles, browser
+  const hasContextPack = messageCount > 0
   const hasMemoryLink = !!(agent && getEnabledToolIds(session).includes('memory'))
   const hasSourceFilter = !!hasMultipleSources
-  const hasContextBar = !!(hasMemoryLink || hasSourceFilter || linkedTask || resumeHandle || browserActive)
+  const hasContextBar = !!(hasContextPack || hasMemoryLink || hasSourceFilter || linkedTask || resumeHandle || browserActive)
 
   return (
     <>
@@ -523,6 +542,20 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
       {hasContextBar && (
         <div className="border-t border-white/[0.05] bg-black/[0.08] px-4 py-2">
         <div className="flex items-center gap-1.5 flex-wrap">
+          {hasContextPack && (
+            <Tip label="Copy session context pack">
+            <button
+              type="button"
+              onClick={handleCopyContextPack}
+              disabled={contextPackLoading}
+              aria-label="Copy session context pack"
+              className="flex min-w-[122px] items-center justify-center gap-1 px-2.5 py-1 rounded-[8px] bg-white/[0.03] hover:bg-white/[0.06] disabled:opacity-70 disabled:cursor-wait transition-colors cursor-pointer text-[10px] font-600 text-text-3/60 hover:text-text-2 shrink-0"
+            >
+              <ClipboardList className="h-3 w-3 shrink-0" aria-hidden="true" strokeWidth={2.2} />
+              <span>{contextPackLoading ? 'Packing' : contextPackCopied ? 'Copied' : 'Context pack'}</span>
+            </button>
+            </Tip>
+          )}
           {hasMemoryLink && (
             <Tip label="View agent memories">
             <button

package/src/lib/server/chats/session-context-pack.test.ts

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  buildSessionContextPack,
+  formatSessionContextPackMarkdown,
+} from '@/lib/server/chats/session-context-pack'
+import type { BoardTask, Message, Session } from '@/types'
+
+function session(overrides: Partial<Session> = {}): Session {
+  return {
+    id: 'session-1',
+    name: 'Release chat',
+    cwd: '/workspace/release',
+    user: 'operator',
+    provider: 'claude-cli',
+    model: 'claude-sonnet-4-6',
+    claudeSessionId: null,
+    messages: [],
+    createdAt: 100,
+    lastActiveAt: 200,
+    agentId: 'agent-1',
+    tools: ['shell', 'files'],
+    extensions: ['release-kit'],
+    runContext: {
+      objective: 'Ship the next release.',
+      constraints: ['Keep public notes concise.'],
+      keyFacts: ['npm is already authenticated.'],
+      discoveries: ['Desktop packaging is slow.'],
+      failedApproaches: [],
+      currentPlan: ['Run tests', 'Cut tag'],
+      completedSteps: ['Bumped version'],
+      blockers: [],
+      parentContext: null,
+      updatedAt: 250,
+      version: 1,
+    },
+    ...overrides,
+  } as Session
+}
+
+function message(overrides: Partial<Message> = {}): Message {
+  return {
+    role: 'user',
+    text: 'Please prepare the release.',
+    time: 300,
+    ...overrides,
+  }
+}
+
+function task(overrides: Partial<BoardTask> = {}): BoardTask {
+  return {
+    id: 'task-1',
+    title: 'Release task',
+    description: 'Prepare and verify the release.',
+    status: 'running',
+    agentId: 'agent-1',
+    sessionId: 'session-1',
+    createdAt: 120,
+    updatedAt: 320,
+    ...overrides,
+  } as BoardTask
+}
+
+describe('session context packs', () => {
+  it('builds a concise pack with linked tasks, attachments, resume handles, and recent visible turns', () => {
+    const pack = buildSessionContextPack({
+      session: session({
+        codexThreadId: 'codex-thread-1',
+        delegateResumeIds: { codex: 'delegate-codex-2' },
+      }),
+      messages: [
+        message({ text: 'Visible user ask', attachedFiles: ['/tmp/spec.md'] }),
+        message({ role: 'assistant', text: 'Hidden note', historyExcluded: true }),
+        message({ role: 'assistant', text: 'Release plan ready.', toolEvents: [{ name: 'shell', input: 'npm test', output: 'passed' }] }),
+      ],
+      tasks: { 'task-1': task({ blockedBy: ['task-2'] }) },
+      now: 500,
+      maxRecentMessages: 8,
+    })
+
+    assert.equal(pack.schemaVersion, 1)
+    assert.equal(pack.session.id, 'session-1')
+    assert.equal(pack.status, 'attention')
+    assert.equal(pack.linkedTasks.length, 1)
+    assert.equal(pack.linkedTasks[0]?.id, 'task-1')
+    assert.equal(pack.attachments[0]?.path, '/tmp/spec.md')
+    assert.deepEqual(pack.resumeHandles.map((handle) => handle.kind), ['codex', 'codex-delegate'])
+    assert.equal(pack.recentMessages.length, 2)
+    assert.ok(pack.recentMessages.every((item) => !item.text.includes('Hidden note')))
+    assert.ok(pack.nextActions.some((action) => action.includes('blocked linked task')))
+  })
+
+  it('renders markdown without provider reasoning, tool output dumps, or hidden transcript turns', () => {
+    const pack = buildSessionContextPack({
+      session: session(),
+      messages: [
+        message({ text: 'Need release context.' }),
+        message({
+          role: 'assistant',
+          text: 'Here is the plan.',
+          reasoningContent: 'private reasoning',
+          thinking: 'internal thought stream',
+          toolEvents: [{ name: 'shell', input: 'npm test', output: 'very long output that should not be rendered' }],
+        }),
+      ],
+      tasks: { 'task-1': task({ status: 'completed', result: 'Release shipped.' }) },
+      now: 800,
+    })
+
+    const markdown = formatSessionContextPackMarkdown(pack)
+
+    assert.match(markdown, /# Session Context Pack: Release chat/)
+    assert.match(markdown, /Provider: claude-cli/)
+    assert.match(markdown, /Linked Tasks/)
+    assert.match(markdown, /Recent Turns/)
+    assert.doesNotMatch(markdown, /private reasoning/)
+    assert.doesNotMatch(markdown, /internal thought stream/)
+    assert.doesNotMatch(markdown, /very long output/)
+  })
+})

package/src/lib/server/chats/session-context-pack.ts

@@ -0,0 +1,387 @@
+import { getContextStatus, type ContextStatus } from '@/lib/server/context-manager'
+import type { BoardTask, Message, Session } from '@/types'
+
+const SYSTEM_PROMPT_TOKEN_ESTIMATE = 2000
+const DEFAULT_RECENT_MESSAGES = 12
+const MAX_RECENT_MESSAGES = 40
+const MAX_TEXT_CHARS = 900
+const MAX_SMALL_TEXT_CHARS = 220
+const MAX_ATTACHMENTS = 20
+
+export type SessionContextPackStatus = 'ready' | 'attention' | 'blocked'
+
+export interface SessionContextPackResumeHandle {
+  kind: string
+  id: string
+  command: string
+}
+
+export interface SessionContextPackMessage {
+  role: Message['role']
+  time: number
+  kind: Message['kind'] | null
+  text: string
+  attachmentCount: number
+  toolCallNames: string[]
+  sourceLabel: string | null
+}
+
+export interface SessionContextPackTask {
+  id: string
+  title: string
+  status: BoardTask['status']
+  agentId: string | null
+  blockedBy: string[]
+  blocks: string[]
+  result: string | null
+  error: string | null
+  updatedAt: number | null
+}
+
+export interface SessionContextPackAttachment {
+  path: string
+  messageIndex: number
+  role: Message['role']
+  time: number
+}
+
+export interface SessionContextPack {
+  schemaVersion: 1
+  generatedAt: number
+  status: SessionContextPackStatus
+  session: {
+    id: string
+    name: string
+    agentId: string | null
+    provider: string
+    model: string
+    cwd: string
+    projectId: string | null
+    missionId: string | null
+    tools: string[]
+    extensions: string[]
+  }
+  connector: {
+    platform: string | null
+    connectorId: string | null
+    scope: string | null
+    threadId: string | null
+    senderName: string | null
+  }
+  messageStats: {
+    total: number
+    visible: number
+    hidden: number
+    attachments: number
+    toolEvents: number
+    lastMessageAt: number | null
+  }
+  context: ContextStatus
+  resumeHandles: SessionContextPackResumeHandle[]
+  linkedTasks: SessionContextPackTask[]
+  attachments: SessionContextPackAttachment[]
+  runContext: {
+    objective: string | null
+    constraints: string[]
+    keyFacts: string[]
+    currentPlan: string[]
+    completedSteps: string[]
+    blockers: string[]
+    updatedAt: number | null
+  }
+  recentMessages: SessionContextPackMessage[]
+  nextActions: string[]
+}
+
+function compactText(value: unknown, maxChars = MAX_TEXT_CHARS): string {
+  if (typeof value !== 'string') return ''
+  const text = value.split(/\s+/).filter(Boolean).join(' ').trim()
+  if (!text) return ''
+  return text.length > maxChars ? `${text.slice(0, maxChars - 3)}...` : text
+}
+
+function compactList(values: unknown, maxItems = 8): string[] {
+  if (!Array.isArray(values)) return []
+  return values
+    .map((item) => compactText(item, MAX_SMALL_TEXT_CHARS))
+    .filter(Boolean)
+    .slice(0, maxItems)
+}
+
+function sourceLabel(message: Message): string | null {
+  const source = message.source
+  if (!source) return null
+  return source.connectorName || source.platform || source.connectorId || null
+}
+
+function isVisibleContextMessage(message: Message): boolean {
+  if (message.suppressed || message.historyExcluded) return false
+  if (message.kind === 'heartbeat' || message.kind === 'context-clear') return false
+  return true
+}
+
+function messageAttachmentPaths(message: Message): string[] {
+  const paths: string[] = []
+  if (Array.isArray(message.attachedFiles)) {
+    paths.push(...message.attachedFiles.filter((item): item is string => typeof item === 'string' && item.trim().length > 0))
+  }
+  if (typeof message.imagePath === 'string' && message.imagePath.trim()) paths.push(message.imagePath.trim())
+  if (typeof message.imageUrl === 'string' && message.imageUrl.trim()) paths.push(message.imageUrl.trim())
+  return Array.from(new Set(paths))
+}
+
+function buildRecentMessages(messages: Message[], maxRecentMessages: number): SessionContextPackMessage[] {
+  return messages
+    .filter(isVisibleContextMessage)
+    .slice(-maxRecentMessages)
+    .map((message) => ({
+      role: message.role,
+      time: message.time,
+      kind: message.kind || null,
+      text: compactText(message.text),
+      attachmentCount: messageAttachmentPaths(message).length,
+      toolCallNames: (message.toolEvents || [])
+        .map((event) => compactText(event.name, 80))
+        .filter(Boolean)
+        .slice(0, 8),
+      sourceLabel: sourceLabel(message),
+    }))
+}
+
+function buildAttachments(messages: Message[]): SessionContextPackAttachment[] {
+  const attachments: SessionContextPackAttachment[] = []
+  messages.forEach((message, messageIndex) => {
+    for (const path of messageAttachmentPaths(message)) {
+      attachments.push({ path, messageIndex, role: message.role, time: message.time })
+    }
+  })
+  return attachments.slice(-MAX_ATTACHMENTS)
+}
+
+function resumeHandles(session: Session): SessionContextPackResumeHandle[] {
+  const handles: SessionContextPackResumeHandle[] = []
+  const push = (kind: string, id: unknown, command: (value: string) => string) => {
+    if (typeof id !== 'string' || !id.trim()) return
+    const value = id.trim()
+    handles.push({ kind, id: value, command: command(value) })
+  }
+  push('claude', session.claudeSessionId, (id) => `claude --resume ${id}`)
+  push('codex', session.codexThreadId, (id) => `codex exec resume ${id}`)
+  push('opencode', session.opencodeSessionId, (id) => `opencode run "<task>" --session ${id}`)
+  push('gemini', session.geminiSessionId, (id) => `gemini --resume ${id} --prompt "<task>"`)
+  push('copilot', session.copilotSessionId, (id) => `copilot -p "<task>" --resume ${id}`)
+  push('droid', session.droidSessionId, (id) => `droid exec "<task>" --resume ${id}`)
+  push('cursor', session.cursorSessionId, (id) => `cursor-agent --resume ${id} --print "<task>"`)
+  push('qwen', session.qwenSessionId, (id) => `qwen --resume ${id} -p "<task>"`)
+
+  const delegate = session.delegateResumeIds || {}
+  push('claude-delegate', delegate.claudeCode, (id) => `claude --resume ${id}`)
+  push('codex-delegate', delegate.codex, (id) => `codex exec resume ${id}`)
+  push('opencode-delegate', delegate.opencode, (id) => `opencode run "<task>" --session ${id}`)
+  push('gemini-delegate', delegate.gemini, (id) => `gemini --resume ${id} --prompt "<task>"`)
+  push('copilot-delegate', delegate.copilot, (id) => `copilot -p "<task>" --resume ${id}`)
+  push('droid-delegate', delegate.droid, (id) => `droid exec "<task>" --resume ${id}`)
+  push('cursor-delegate', delegate.cursor, (id) => `cursor-agent --resume ${id} --print "<task>"`)
+  push('qwen-delegate', delegate.qwen, (id) => `qwen --resume ${id} -p "<task>"`)
+  return handles
+}
+
+function linkedTasksForSession(session: Session, tasks: Record<string, BoardTask>): SessionContextPackTask[] {
+  return Object.values(tasks)
+    .filter((task) => task.sessionId === session.id || task.createdInSessionId === session.id)
+    .sort((left, right) => (right.updatedAt || 0) - (left.updatedAt || 0))
+    .slice(0, 8)
+    .map((task) => ({
+      id: task.id,
+      title: task.title || task.id,
+      status: task.status,
+      agentId: task.agentId || null,
+      blockedBy: Array.isArray(task.blockedBy) ? task.blockedBy.filter(Boolean) : [],
+      blocks: Array.isArray(task.blocks) ? task.blocks.filter(Boolean) : [],
+      result: compactText(task.result, MAX_SMALL_TEXT_CHARS) || null,
+      error: compactText(task.error, MAX_SMALL_TEXT_CHARS) || null,
+      updatedAt: typeof task.updatedAt === 'number' ? task.updatedAt : null,
+    }))
+}
+
+function buildNextActions(input: {
+  context: ContextStatus
+  linkedTasks: SessionContextPackTask[]
+  recentMessages: SessionContextPackMessage[]
+  resumeHandles: SessionContextPackResumeHandle[]
+  session: Session
+}): string[] {
+  const actions: string[] = []
+  if (input.context.strategy === 'critical') {
+    actions.push('Compact the chat or start a new context window before continuing long work.')
+  } else if (input.context.strategy === 'warning') {
+    actions.push('Consider compacting soon; the context window is approaching the reserve limit.')
+  }
+  if (input.linkedTasks.some((task) => task.blockedBy.length > 0 && task.status !== 'completed')) {
+    actions.push('Resolve the blocked linked task before handing this session to another operator.')
+  }
+  if (input.linkedTasks.some((task) => task.status === 'failed' || task.status === 'cancelled')) {
+    actions.push('Review failed or cancelled linked tasks before resuming the session.')
+  }
+  if (input.resumeHandles.length > 0) {
+    actions.push('Use a resume handle if continuing work in the matching CLI backend.')
+  }
+  if (!input.session.agentId) {
+    actions.push('Link an agent when this context needs durable memory, tools, or scheduled follow-up.')
+  }
+  if (input.recentMessages.length === 0) {
+    actions.push('Add the current objective before handing off; no visible recent turns are available.')
+  }
+  if (actions.length === 0) actions.push('Share this context pack with the next operator or agent before switching execution paths.')
+  return Array.from(new Set(actions)).slice(0, 8)
+}
+
+function statusFrom(context: ContextStatus, linkedTasks: SessionContextPackTask[], recentMessages: SessionContextPackMessage[]): SessionContextPackStatus {
+  if (context.strategy === 'critical') return 'blocked'
+  if (linkedTasks.some((task) => task.status === 'failed' || task.status === 'cancelled')) return 'blocked'
+  if (context.strategy === 'warning') return 'attention'
+  if (linkedTasks.some((task) => task.blockedBy.length > 0 && task.status !== 'completed')) return 'attention'
+  if (recentMessages.length === 0) return 'attention'
+  return 'ready'
+}
+
+export function buildSessionContextPack(input: {
+  session: Session
+  messages: Message[]
+  tasks?: Record<string, BoardTask>
+  now?: number
+  maxRecentMessages?: number
+}): SessionContextPack {
+  const now = input.now ?? Date.now()
+  const maxRecentMessages = Math.max(1, Math.min(MAX_RECENT_MESSAGES, Math.trunc(input.maxRecentMessages || DEFAULT_RECENT_MESSAGES)))
+  const messages = Array.isArray(input.messages) ? input.messages : []
+  const context = getContextStatus(messages, SYSTEM_PROMPT_TOKEN_ESTIMATE, String(input.session.provider || ''), String(input.session.model || ''))
+  const recentMessages = buildRecentMessages(messages, maxRecentMessages)
+  const attachments = buildAttachments(messages)
+  const linkedTasks = linkedTasksForSession(input.session, input.tasks || {})
+  const handles = resumeHandles(input.session)
+  const hidden = messages.filter((message) => !isVisibleContextMessage(message)).length
+  const toolEvents = messages.reduce((sum, message) => sum + (message.toolEvents?.length || 0), 0)
+  const nextActions = buildNextActions({ context, linkedTasks, recentMessages, resumeHandles: handles, session: input.session })
+
+  return {
+    schemaVersion: 1,
+    generatedAt: now,
+    status: statusFrom(context, linkedTasks, recentMessages),
+    session: {
+      id: input.session.id,
+      name: input.session.name || input.session.id,
+      agentId: input.session.agentId || null,
+      provider: String(input.session.provider || ''),
+      model: String(input.session.model || ''),
+      cwd: input.session.cwd || '',
+      projectId: input.session.projectId || null,
+      missionId: input.session.missionId || null,
+      tools: Array.isArray(input.session.tools) ? input.session.tools.filter(Boolean) : [],
+      extensions: Array.isArray(input.session.extensions) ? input.session.extensions.filter(Boolean) : [],
+    },
+    connector: {
+      platform: input.session.connectorContext?.platform || null,
+      connectorId: input.session.connectorContext?.connectorId || null,
+      scope: input.session.connectorContext?.scope || null,
+      threadId: input.session.connectorContext?.threadId || null,
+      senderName: input.session.connectorContext?.senderName || null,
+    },
+    messageStats: {
+      total: messages.length,
+      visible: messages.length - hidden,
+      hidden,
+      attachments: attachments.length,
+      toolEvents,
+      lastMessageAt: messages.at(-1)?.time || null,
+    },
+    context,
+    resumeHandles: handles,
+    linkedTasks,
+    attachments,
+    runContext: {
+      objective: compactText(input.session.runContext?.objective, MAX_SMALL_TEXT_CHARS) || null,
+      constraints: compactList(input.session.runContext?.constraints),
+      keyFacts: compactList(input.session.runContext?.keyFacts),
+      currentPlan: compactList(input.session.runContext?.currentPlan),
+      completedSteps: compactList(input.session.runContext?.completedSteps),
+      blockers: compactList(input.session.runContext?.blockers),
+      updatedAt: input.session.runContext?.updatedAt || null,
+    },
+    recentMessages,
+    nextActions,
+  }
+}
+
+function iso(value: number | null | undefined): string {
+  return typeof value === 'number' && Number.isFinite(value) ? new Date(value).toISOString() : 'n/a'
+}
+
+function bulletList(items: string[], empty: string): string[] {
+  if (items.length === 0) return [`- ${empty}`]
+  return items.map((item) => `- ${item}`)
+}
+
+export function formatSessionContextPackMarkdown(pack: SessionContextPack): string {
+  const lines: string[] = []
+  lines.push(`# Session Context Pack: ${pack.session.name}`)
+  lines.push('')
+  lines.push(`Generated: ${iso(pack.generatedAt)}`)
+  lines.push(`Status: ${pack.status}`)
+  lines.push(`Session: ${pack.session.id}`)
+  lines.push(`Provider: ${pack.session.provider}${pack.session.model ? ` / ${pack.session.model}` : ''}`)
+  lines.push(`Agent: ${pack.session.agentId || 'n/a'}`)
+  lines.push(`Working directory: ${pack.session.cwd || 'n/a'}`)
+  lines.push(`Messages: ${pack.messageStats.visible} visible / ${pack.messageStats.total} total`)
+  lines.push(`Context: ${pack.context.percentUsed}% used, ${pack.context.remainingTokens.toLocaleString()} tokens remaining`)
+  lines.push('')
+  lines.push('## Next Actions')
+  lines.push(...bulletList(pack.nextActions, 'No immediate action required.'))
+  lines.push('')
+  lines.push('## Run Context')
+  lines.push(`Objective: ${pack.runContext.objective || 'n/a'}`)
+  lines.push(...bulletList(pack.runContext.currentPlan.map((item) => `Plan: ${item}`), 'No current plan recorded.'))
+  lines.push(...bulletList(pack.runContext.blockers.map((item) => `Blocker: ${item}`), 'No blockers recorded.'))
+  lines.push('')
+  lines.push('## Linked Tasks')
+  if (pack.linkedTasks.length === 0) {
+    lines.push('- No linked tasks.')
+  } else {
+    for (const task of pack.linkedTasks) {
+      const blockers = task.blockedBy.length > 0 ? `, blocked by ${task.blockedBy.join(', ')}` : ''
+      lines.push(`- ${task.id}: ${task.title} (${task.status}${blockers})`)
+      if (task.result) lines.push(`  - Result: ${task.result}`)
+      if (task.error) lines.push(`  - Error: ${task.error}`)
+    }
+  }
+  lines.push('')
+  lines.push('## Resume Handles')
+  if (pack.resumeHandles.length === 0) {
+    lines.push('- No external resume handles.')
+  } else {
+    for (const handle of pack.resumeHandles) lines.push(`- ${handle.kind}: \`${handle.command}\``)
+  }
+  lines.push('')
+  lines.push('## Attachments')
+  if (pack.attachments.length === 0) {
+    lines.push('- No attachments in the visible pack window.')
+  } else {
+    for (const attachment of pack.attachments) {
+      lines.push(`- ${attachment.path} (${attachment.role}, ${iso(attachment.time)})`)
+    }
+  }
+  lines.push('')
+  lines.push('## Recent Turns')
+  if (pack.recentMessages.length === 0) {
+    lines.push('- No visible recent turns.')
+  } else {
+    for (const message of pack.recentMessages) {
+      const tools = message.toolCallNames.length > 0 ? ` Tools: ${message.toolCallNames.join(', ')}.` : ''
+      const attachments = message.attachmentCount > 0 ? ` Attachments: ${message.attachmentCount}.` : ''
+      const source = message.sourceLabel ? ` Source: ${message.sourceLabel}.` : ''
+      lines.push(`- ${message.role} at ${iso(message.time)}:${source}${attachments}${tools} ${message.text || '[no text]'}`.trim())
+    }
+  }
+  lines.push('')
+  return lines.join('\n')
+}

package/src/lib/server/memory/memory-abstract.ts

@@ -1,6 +1,5 @@
 /**
  * Generates concise abstracts (~100 tokens) for memory entries.
- * Inspired by OpenViking's L0/L1/L2 tiered context representations.
  *
  * Used in proactive recall to inject summaries instead of truncated raw content,
  * reducing token waste and preserving semantic meaning.

package/src/lib/server/memory/temporal-decay.ts

@@ -3,7 +3,6 @@
  *
  * Applies exponential decay to memory search scores based on entry age.
  * Older memories score lower, surfacing recent relevant context preferentially.
- * Inspired by OpenClaw's temporal-decay.ts.
  */
 
 export interface TemporalDecayConfig {

package/src/lib/server/runtime/wake-mode.ts

@@ -3,9 +3,6 @@
  *
  * Replaces the implicit `source: 'heartbeat' | 'heartbeat-wake'` convention
  * with a formal enum that determines routing, priority, and isolation behavior.
- *
- * Inspired by OpenClaw's separation of "run now" vs "queue next heartbeat" vs
- * scheduled execution with proper isolation.
  */
 
 // ── WakeMode enum ───────────────────────────────────────────────────────

package/src/lib/server/skills/skill-prompt-budget.ts

@@ -84,8 +84,8 @@ export function budgetSkillsForPrompt(
 
 /**
  * Prescriptive skill adherence header.
- * This tells the model exactly when and how to use skills — the key difference
- * vs OpenClaw's superior skill following (1-2 tool calls vs 3-5).
+ * This tells the model exactly when and how to use skills so it can keep
+ * skill-backed turns focused and economical.
  */
 const SKILL_ADHERENCE_HEADER = `## Skills
 

package/src/lib/server/workspace-context.ts

@@ -1,9 +1,6 @@
 /**
  * Workspace context injection — injects workspace files into the agent's system prompt.
  *
- * Inspired by OpenClaw's pattern of injecting HEARTBEAT.md, IDENTITY.md, AGENTS.md,
- * SOUL.md, TOOLS.md, USER.md, and BOOTSTRAP.md into every agent turn.
- *
  * This gives agents self-awareness, goals, and context about their operating environment
  * without requiring the user to manually configure everything.
  */