airaknit 1.1.2-rc.9

package/src/server/workflow-store.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { mkdtemp, writeFile, rm } from "node:fs/promises"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { WorkflowStore, WorkflowParseError } from "./workflow-store"
+
+
+let tmpDirs: string[] = []
+
+async function makeTmpDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "wf-store-test-"))
+  tmpDirs.push(dir)
+  return dir
+}
+
+async function writeYaml(dir: string, filename: string, content: string): Promise<void> {
+  await writeFile(join(dir, filename), content, "utf-8")
+}
+
+afterEach(async () => {
+  for (const dir of tmpDirs) {
+    await rm(dir, { recursive: true, force: true }).catch(() => {})
+  }
+  tmpDirs = []
+})
+
+describe("WorkflowStore", () => {
+  test("list() returns all .yaml files parsed and sorted by name", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "beta.yaml", `name: Beta\nsteps:\n  - mcp_tool: do_thing`)
+    await writeYaml(dir, "alpha.yaml", `name: Alpha\nsteps:\n  - mcp_tool: do_other`)
+    // non-yaml file should be ignored
+    await writeFile(join(dir, "readme.txt"), "not a workflow")
+
+    const store = new WorkflowStore(dir)
+    const results = await store.list()
+
+    expect(results).toHaveLength(2)
+    expect(results[0].name).toBe("Alpha")
+    expect(results[0].id).toBe("alpha")
+    expect(results[1].name).toBe("Beta")
+    expect(results[1].id).toBe("beta")
+  })
+
+  test("get(id) returns specific workflow by id", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "deploy.yaml", `name: Deploy\nsteps:\n  - mcp_tool: run_deploy`)
+
+    const store = new WorkflowStore(dir)
+    const wf = await store.get("deploy")
+
+    expect(wf).not.toBeNull()
+    expect(wf!.id).toBe("deploy")
+    expect(wf!.name).toBe("Deploy")
+    expect(wf!.steps[0].mcp_tool).toBe("run_deploy")
+  })
+
+  test("get(id) returns null for non-existent workflow", async () => {
+    const dir = await makeTmpDir()
+    const store = new WorkflowStore(dir)
+    const wf = await store.get("nope")
+    expect(wf).toBeNull()
+  })
+
+  test("parses valid YAML with manual trigger", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "m.yaml", `name: Manual\ntrigger: manual\nsteps:\n  - mcp_tool: x`)
+
+    const store = new WorkflowStore(dir)
+    const wf = await store.get("m")
+    expect(wf!.trigger).toBe("manual")
+  })
+
+  test("parses valid YAML with cron trigger", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "c.yaml", `name: Cron\ntrigger:\n  cron: "*/5 * * * *"\nsteps:\n  - mcp_tool: x`)
+
+    const store = new WorkflowStore(dir)
+    const wf = await store.get("c")
+    expect(wf!.trigger).toEqual({ cron: "*/5 * * * *" })
+  })
+
+  test("parses valid YAML with on_event trigger", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "e.yaml", `name: Event\ntrigger:\n  on_event: push\nsteps:\n  - mcp_tool: x`)
+
+    const store = new WorkflowStore(dir)
+    const wf = await store.get("e")
+    expect(wf!.trigger).toEqual({ on_event: "push" })
+  })
+
+  test("rejects YAML missing name", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "bad.yaml", `steps:\n  - mcp_tool: x`)
+
+    const store = new WorkflowStore(dir)
+    await expect(store.get("bad")).rejects.toBeInstanceOf(WorkflowParseError)
+  })
+
+  test("rejects YAML missing steps", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "bad.yaml", `name: Bad`)
+
+    const store = new WorkflowStore(dir)
+    await expect(store.get("bad")).rejects.toBeInstanceOf(WorkflowParseError)
+  })
+
+  test("rejects YAML with empty steps array", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "bad.yaml", `name: Bad\nsteps: []`)
+
+    const store = new WorkflowStore(dir)
+    await expect(store.get("bad")).rejects.toBeInstanceOf(WorkflowParseError)
+  })
+
+  test("rejects YAML with invalid on_failure value", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "bad.yaml", `name: Bad\nsteps:\n  - mcp_tool: x\non_failure: explode`)
+
+    const store = new WorkflowStore(dir)
+    await expect(store.get("bad")).rejects.toBeInstanceOf(WorkflowParseError)
+  })
+
+  test("applies default values: trigger=manual, target=all, on_failure=stop, params={}", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "defaults.yaml", `name: Defaults\nsteps:\n  - mcp_tool: foo`)
+
+    const store = new WorkflowStore(dir)
+    const wf = await store.get("defaults")
+
+    expect(wf!.trigger).toBe("manual")
+    expect(wf!.target).toBe("all")
+    expect(wf!.on_failure).toBe("stop")
+    expect(wf!.steps[0].params).toEqual({})
+  })
+
+  test("list() skips files that fail parsing and warns", async () => {
+    const dir = await makeTmpDir()
+    await writeYaml(dir, "good.yaml", `name: Good\nsteps:\n  - mcp_tool: x`)
+    await writeYaml(dir, "bad.yaml", `steps: []`) // missing name AND empty steps
+
+    const warnings: string[] = []
+    const origWarn = console.warn
+    console.warn = (...args: unknown[]) => { warnings.push(String(args[0])) }
+
+    const store = new WorkflowStore(dir)
+    const results = await store.list()
+
+    console.warn = origWarn
+
+    expect(results).toHaveLength(1)
+    expect(results[0].name).toBe("Good")
+    expect(warnings.length).toBeGreaterThan(0)
+  })
+})

package/src/server/workflow-store.ts

@@ -0,0 +1,139 @@
+import { readdir, readFile } from "node:fs/promises"
+import { join, basename } from "node:path"
+import yaml from "js-yaml"
+import type { WorkflowDefinition, WorkflowStep, WorkflowTrigger } from "../shared/workflow-types"
+
+const LOG_PREFIX = "[workflow-store]"
+
+export class WorkflowParseError extends Error {
+  constructor(
+    public readonly workflowId: string,
+    public readonly field: string,
+    message: string,
+  ) {
+    super(`[${workflowId}] ${field}: ${message}`)
+    this.name = "WorkflowParseError"
+  }
+}
+
+export class WorkflowStore {
+  constructor(private readonly workflowsDir: string) {}
+
+  async list(): Promise<WorkflowDefinition[]> {
+    let entries: string[]
+    try {
+      entries = await readdir(this.workflowsDir)
+    } catch (err) {
+      console.warn(`${LOG_PREFIX} Cannot read workflows dir: ${err instanceof Error ? err.message : String(err)}`)
+      return []
+    }
+
+    const yamlFiles = entries.filter((f) => f.endsWith(".yaml")).sort()
+    const results: WorkflowDefinition[] = []
+
+    for (const file of yamlFiles) {
+      const id = basename(file, ".yaml")
+      try {
+        const content = await readFile(join(this.workflowsDir, file), "utf-8")
+        const raw = yaml.load(content)
+        results.push(this.parseYaml(id, raw))
+      } catch (err) {
+        console.warn(`${LOG_PREFIX} Skipping ${file}: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+
+    return results.sort((a, b) => a.name.localeCompare(b.name))
+  }
+
+  async get(id: string): Promise<WorkflowDefinition | null> {
+    const filePath = join(this.workflowsDir, `${id}.yaml`)
+    let content: string
+    try {
+      content = await readFile(filePath, "utf-8")
+    } catch {
+      return null
+    }
+    const raw = yaml.load(content)
+    return this.parseYaml(id, raw)
+  }
+
+  private parseYaml(id: string, raw: unknown): WorkflowDefinition {
+    if (typeof raw !== "object" || raw === null) {
+      throw new WorkflowParseError(id, "root", "must be an object")
+    }
+
+    const obj = raw as Record<string, unknown>
+
+    // name
+    if (typeof obj.name !== "string" || obj.name.trim() === "") {
+      throw new WorkflowParseError(id, "name", "must be a non-empty string")
+    }
+
+    // trigger
+    let trigger: WorkflowTrigger = "manual"
+    if (obj.trigger !== undefined) {
+      if (obj.trigger === "manual") {
+        trigger = "manual"
+      } else if (typeof obj.trigger === "object" && obj.trigger !== null) {
+        const t = obj.trigger as Record<string, unknown>
+        if (typeof t.cron === "string") {
+          trigger = { cron: t.cron }
+        } else if (typeof t.on_event === "string") {
+          trigger = { on_event: t.on_event }
+        } else {
+          throw new WorkflowParseError(id, "trigger", "must be 'manual', {cron: string}, or {on_event: string}")
+        }
+      } else {
+        throw new WorkflowParseError(id, "trigger", "must be 'manual', {cron: string}, or {on_event: string}")
+      }
+    }
+
+    // target
+    let target: string = "all"
+    if (obj.target !== undefined) {
+      if (typeof obj.target !== "string" || obj.target.trim() === "") {
+        throw new WorkflowParseError(id, "target", "must be 'all' or a non-empty string")
+      }
+      target = obj.target
+    }
+
+    // steps
+    if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+      throw new WorkflowParseError(id, "steps", "must be a non-empty array")
+    }
+
+    const steps: WorkflowStep[] = obj.steps.map((s: unknown, i: number) => {
+      if (typeof s !== "object" || s === null) {
+        throw new WorkflowParseError(id, `steps[${i}]`, "must be an object")
+      }
+      const step = s as Record<string, unknown>
+      if (typeof step.mcp_tool !== "string") {
+        throw new WorkflowParseError(id, `steps[${i}].mcp_tool`, "must be a string")
+      }
+      return {
+        mcp_tool: step.mcp_tool,
+        params: (typeof step.params === "object" && step.params !== null ? step.params : {}) as Record<string, unknown>,
+        ...(typeof step.label === "string" ? { label: step.label } : {}),
+      }
+    })
+
+    // on_failure
+    const validFailures = ["stop", "continue", "rollback"] as const
+    let onFailure: "stop" | "continue" | "rollback" = "stop"
+    if (obj.on_failure !== undefined) {
+      if (!validFailures.includes(obj.on_failure as typeof validFailures[number])) {
+        throw new WorkflowParseError(id, "on_failure", `must be one of: ${validFailures.join(", ")}`)
+      }
+      onFailure = obj.on_failure as "stop" | "continue" | "rollback"
+    }
+
+    return {
+      id,
+      name: obj.name,
+      trigger,
+      target,
+      steps,
+      on_failure: onFailure,
+    }
+  }
+}

package/src/server/workspace-agent-integration.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, test, afterEach } from "bun:test"
+import { SessionIndex } from "./session-index"
+import { EventStore } from "./event-store"
+import { TranscriptSearchIndex } from "./transcript-search"
+import { WorkspaceAgent } from "./workspace-agent"
+import { createWorkspaceAgentRouter } from "./workspace-agent-routes"
+import type { TranscriptEntry } from "../shared/types"
+import type { StoreState, ChatRecord } from "./events"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+
+let tempDirs: string[] = []
+
+function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
+  entry: T,
+): TranscriptEntry {
+  return { _id: crypto.randomUUID(), createdAt: Date.now(), ...entry } as TranscriptEntry
+}
+
+async function createIntegration() {
+  const dir = await mkdtemp(path.join(tmpdir(), "pa-integration-test-"))
+  tempDirs.push(dir)
+  const store = new EventStore(dir)
+  await store.initialize()
+  const sessions = new SessionIndex()
+  const search = new TranscriptSearchIndex()
+  const project = await store.openProject("/tmp/test-integration", "Integration Test")
+  const workspaceId = project.id
+  const agent = new WorkspaceAgent({ sessions, store, search, workspaceId })
+  const router = createWorkspaceAgentRouter(agent)
+  return { store, sessions, search, agent, router, workspaceId }
+}
+
+afterEach(async () => {
+  for (const d of tempDirs) await rm(d, { recursive: true, force: true })
+  tempDirs = []
+})
+
+function makeState(workspaceId: string): StoreState {
+  const workspacesById = new Map([[workspaceId, { id: workspaceId, localPath: "/tmp/p", title: "Test", createdAt: 0, updatedAt: 0 }]])
+  const workspaceIdsByPath = new Map<string, string>()
+  const chatsById = new Map<string, ChatRecord>([
+    ["c1", {
+      id: "c1", workspaceId, repoId: null, title: "Chat 1", createdAt: Date.now(), updatedAt: Date.now(),
+      unread: false, provider: "claude", planMode: false, sessionToken: null, lastTurnOutcome: null,
+    }],
+    ["c2", {
+      id: "c2", workspaceId, repoId: null, title: "Chat 2", createdAt: Date.now(), updatedAt: Date.now(),
+      unread: false, provider: "codex", planMode: false, sessionToken: null, lastTurnOutcome: null,
+    }],
+  ])
+  return { workspacesById, workspaceIdsByPath, independentWorkspacesById: new Map(), chatsById, queuedTurnsByChat: new Map(), coordinationByWorkspace: new Map(), agentConfigsByWorkspace: new Map(), reposById: new Map(), reposByPath: new Map(), workflowRunsByWorkspace: new Map(), sandboxByWorkspace: new Map(), providerProfiles: new Map(), workspaceProfileOverrides: new Map(), extensionPreferences: new Map(), teamMembers: new Map(), runnerLabels: new Map() }
+}
+
+describe("project agent integration", () => {
+  test("end-to-end: messages → indexes → query via HTTP routes", async () => {
+    const { sessions, search, router, workspaceId } = await createIntegration()
+    const state = makeState(workspaceId)
+
+    // Simulate two sessions sending messages
+    const e1 = timestamped({ kind: "user_prompt", content: "implement auth middleware with JWT" })
+    const e2 = timestamped({ kind: "user_prompt", content: "fix CSS styling on the sidebar component" })
+    sessions.onMessageAppended("c1", e1, state)
+    sessions.onMessageAppended("c2", e2, state)
+    search.addEntry("c1", e1)
+    search.addEntry("c2", e2)
+
+    // Query sessions via HTTP
+    const sessionsRes = await router(new Request(`http://localhost/api/workspace/sessions?workspaceId=${workspaceId}`))
+    const sessionsBody = await sessionsRes.json() as Array<Record<string, unknown>>
+    expect(sessionsRes.status).toBe(200)
+    expect(sessionsBody.length).toBe(2)
+
+    // Search transcripts via HTTP
+    const searchRes = await router(new Request("http://localhost/api/workspace/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: "auth JWT middleware", limit: 5 }),
+    }))
+    const searchBody = await searchRes.json() as Array<Record<string, unknown>>
+    expect(searchRes.status).toBe(200)
+    expect(searchBody.length).toBeGreaterThanOrEqual(1)
+    expect(searchBody[0].chatId).toBe("c1")
+
+    // Claim task via HTTP
+    const claimRes = await router(new Request("http://localhost/api/workspace/claim", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ description: "implement auth middleware", session: "c1", branch: "feat/auth" }),
+    }))
+    const claimBody = await claimRes.json() as Record<string, unknown>
+    expect(claimRes.status).toBe(200)
+    expect(claimBody.status).toBe("claimed")
+
+    // List tasks via HTTP
+    const tasksRes = await router(new Request("http://localhost/api/workspace/tasks"))
+    const tasksBody = await tasksRes.json() as Array<Record<string, unknown>>
+    expect(tasksBody.length).toBe(1)
+
+    // Delegate via HTTP
+    const delegateRes = await router(new Request("http://localhost/api/workspace/delegate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ request: "who is working on auth?" }),
+    }))
+    const delegateBody = await delegateRes.json() as Record<string, unknown>
+    expect(delegateBody.status).toBe("ok")
+    expect((delegateBody.message as string).toLowerCase()).toContain("auth")
+  })
+
+  test("tasks survive EventStore reload (durability)", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "durable-"))
+    tempDirs.push(dir)
+
+    // First store instance: create a task
+    const store1 = new EventStore(dir)
+    await store1.initialize()
+    const project1 = await store1.openProject("/tmp/durable", "Durable Test")
+    const agent1 = new WorkspaceAgent({
+      sessions: new SessionIndex(),
+      store: store1,
+      search: new TranscriptSearchIndex(),
+      workspaceId: project1.id,
+    })
+    const task = await agent1.claimTask("durable task", "session-1", null)
+
+    // Second store instance: reload from same directory
+    const store2 = new EventStore(dir)
+    await store2.initialize()
+    const agent2 = new WorkspaceAgent({
+      sessions: new SessionIndex(),
+      store: store2,
+      search: new TranscriptSearchIndex(),
+      workspaceId: project1.id,
+    })
+
+    const tasks = agent2.listTasks()
+    expect(tasks.length).toBe(1)
+    expect(tasks[0].description).toBe("durable task")
+    expect(tasks[0].status).toBe("claimed")
+    expect(tasks[0].id).toBe(task.id)
+  })
+
+  test("complete task lifecycle via HTTP", async () => {
+    const { router } = await createIntegration()
+
+    // Claim
+    const claimRes = await router(new Request("http://localhost/api/workspace/claim", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ description: "setup database", session: "c1", branch: null }),
+    }))
+    const claimed = await claimRes.json() as Record<string, unknown>
+    expect(claimed.status).toBe("claimed")
+
+    // Complete
+    const completeRes = await router(new Request("http://localhost/api/workspace/complete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ taskId: claimed.id, outputs: ["migrations/001.sql"] }),
+    }))
+    const completed = await completeRes.json() as Record<string, unknown>
+    expect(completed.status).toBe("complete")
+    expect(completed.outputs).toEqual(["migrations/001.sql"])
+  })
+})

package/src/server/workspace-agent-routes.test.ts

@@ -0,0 +1,127 @@
+// src/server/project-agent-routes.test.ts
+import { describe, expect, test, afterEach } from "bun:test"
+import { createWorkspaceAgentRouter } from "./workspace-agent-routes"
+import { SessionIndex } from "./session-index"
+import { EventStore } from "./event-store"
+import { TranscriptSearchIndex } from "./transcript-search"
+import { WorkspaceAgent } from "./workspace-agent"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+
+let tempDirs: string[] = []
+
+async function createRouter() {
+  const dir = await mkdtemp(path.join(tmpdir(), "pa-routes-test-"))
+  tempDirs.push(dir)
+  const store = new EventStore(dir)
+  await store.initialize()
+  const sessions = new SessionIndex()
+  const search = new TranscriptSearchIndex()
+  const project = await store.openProject("/tmp/test", "Test Project")
+  const workspaceId = project.id
+  const agent = new WorkspaceAgent({ sessions, store, search, workspaceId })
+  const router = createWorkspaceAgentRouter(agent)
+  return { router, agent, sessions, store, search, workspaceId }
+}
+
+afterEach(async () => {
+  for (const d of tempDirs) await rm(d, { recursive: true, force: true })
+  tempDirs = []
+})
+
+describe("project-agent-routes", () => {
+  test("GET /api/workspace/sessions returns JSON array", async () => {
+    const { router, workspaceId } = await createRouter()
+    const req = new Request(`http://localhost/api/workspace/sessions?workspaceId=${workspaceId}`)
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(Array.isArray(body)).toBe(true)
+  })
+
+  test("POST /api/workspace/search returns results", async () => {
+    const { router, search } = await createRouter()
+    search.addEntry("c1", { _id: "1", createdAt: Date.now(), kind: "user_prompt", content: "auth setup" } as never)
+
+    const req = new Request("http://localhost/api/workspace/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: "auth", limit: 10 }),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(Array.isArray(body)).toBe(true)
+  })
+
+  test("GET /api/workspace/tasks returns task list", async () => {
+    const { router, agent } = await createRouter()
+    await agent.claimTask("test task", "c1", null)
+
+    const req = new Request("http://localhost/api/workspace/tasks")
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.length).toBe(1)
+  })
+
+  test("POST /api/workspace/claim creates a task", async () => {
+    const { router } = await createRouter()
+    const req = new Request("http://localhost/api/workspace/claim", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ description: "implement auth", session: "c1", branch: "feat/auth" }),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.status).toBe("claimed")
+  })
+
+  test("POST /api/workspace/complete marks task done", async () => {
+    const { router, agent } = await createRouter()
+    const task = await agent.claimTask("task", "c1", null)
+
+    const req = new Request("http://localhost/api/workspace/complete", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ taskId: task.id, outputs: ["file.ts"] }),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.status).toBe("complete")
+  })
+
+  test("POST /api/workspace/delegate returns delegation result", async () => {
+    const { router } = await createRouter()
+    const req = new Request("http://localhost/api/workspace/delegate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ request: "what is going on?" }),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.status).toBe("ok")
+  })
+
+  test("returns 404 for unknown routes", async () => {
+    const { router } = await createRouter()
+    const req = new Request("http://localhost/api/workspace/nonexistent")
+    const res = await router(req)
+    expect(res.status).toBe(404)
+  })
+
+  test("returns 400 for missing required fields", async () => {
+    const { router } = await createRouter()
+    const req = new Request("http://localhost/api/workspace/claim", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    })
+    const res = await router(req)
+    expect(res.status).toBe(400)
+  })
+})

package/src/server/workspace-agent-routes.ts

@@ -0,0 +1,89 @@
+// src/server/project-agent-routes.ts
+import { LOG_PREFIX } from "../shared/branding"
+import type { WorkspaceAgent } from "./workspace-agent"
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  })
+}
+
+function errorResponse(error: string, code: number, detail?: string): Response {
+  return jsonResponse({ error, code, detail }, code)
+}
+
+async function readBody(req: Request): Promise<Record<string, unknown>> {
+  try {
+    return (await req.json()) as Record<string, unknown>
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err)
+    console.warn(`${LOG_PREFIX} readBody: invalid JSON — ${message}`)
+    return {}
+  }
+}
+
+export function createWorkspaceAgentRouter(agent: WorkspaceAgent): (req: Request) => Promise<Response> {
+  return async (req: Request): Promise<Response> => {
+    const url = new URL(req.url)
+    const path = url.pathname.replace(/^\/api\/workspace/, "")
+
+    if (req.method === "GET" && path === "/sessions") {
+      const workspaceId = url.searchParams.get("workspaceId") ?? ""
+      return jsonResponse(agent.querySessions(workspaceId))
+    }
+
+    if (req.method === "GET" && path.startsWith("/sessions/")) {
+      const chatId = path.replace("/sessions/", "")
+      const session = agent.getSessionSummary(chatId)
+      return session ? jsonResponse(session) : errorResponse("Session not found", 404)
+    }
+
+    if (req.method === "POST" && path === "/search") {
+      const body = await readBody(req)
+      const query = body.query as string | undefined
+      if (!query) return errorResponse("Missing 'query'", 400)
+      const rawLimit = body.limit
+      const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) && rawLimit > 0 ? rawLimit : 10
+      return jsonResponse(agent.searchWork(query, limit))
+    }
+
+    if (req.method === "GET" && path === "/tasks") {
+      return jsonResponse(agent.listTasks())
+    }
+
+    if (req.method === "GET" && path.startsWith("/tasks/")) {
+      const taskId = path.replace("/tasks/", "")
+      const task = agent.getTask(taskId)
+      return task ? jsonResponse(task) : errorResponse("Task not found", 404)
+    }
+
+    if (req.method === "POST" && path === "/claim") {
+      const body = await readBody(req)
+      const description = body.description as string | undefined
+      const session = body.session as string | undefined
+      if (!description || !session) return errorResponse("Missing 'description' or 'session'", 400)
+      const branch = (body.branch as string) ?? null
+      return jsonResponse(await agent.claimTask(description, session, branch))
+    }
+
+    if (req.method === "POST" && path === "/complete") {
+      const body = await readBody(req)
+      const taskId = body.taskId as string | undefined
+      if (!taskId) return errorResponse("Missing 'taskId'", 400)
+      const outputs = Array.isArray(body.outputs) ? (body.outputs as string[]) : []
+      const task = await agent.completeTask(taskId, outputs)
+      return task ? jsonResponse(task) : errorResponse("Task not found", 404)
+    }
+
+    if (req.method === "POST" && path === "/delegate") {
+      const body = await readBody(req)
+      const request = body.request as string | undefined
+      if (!request) return errorResponse("Missing 'request'", 400)
+      const result = await agent.delegate(request)
+      return jsonResponse(result)
+    }
+
+    return errorResponse("Not found", 404)
+  }
+}