ework-aio 0.5.36 → 0.5.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.5.36",
+  "version": "0.5.38",
   "description": "All-in-one installer for ework (issue tracker) + ework-daemon (AI bridge) + opencode-ework (plugin). One command: npm i -g ework-aio && ework-aio install.",
   "type": "module",
   "license": "MIT",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "ework-daemon": "^0.4.1",
-    "ework-router": "^0.1.5",
+    "ework-router": "^0.1.7",
     "ework-web": "^0.10.15",
     "opencode-ework": "^0.1.0",
     "zod": "^3.23.0"

package/scripts/e2e-router.sh

@@ -0,0 +1,231 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+NPM_TAG="${2:-latest}"
+DATA_DIR="${E2E_DATA_DIR:-/tmp/e2e-router}"
+FAKE_HOME="${E2E_FAKE_HOME:-/tmp/e2e-router-home}"
+FAKE_LLM_PORT="${E2E_LLM_PORT:-8401}"
+WEB_PORT="${E2E_WEB_PORT:-3002}"
+ROUTER_PORT="${E2E_ROUTER_PORT:-3104}"
+D1_PORT="${E2E_D1_PORT:-3101}"
+D2_PORT="${E2E_D2_PORT:-3102}"
+D3_PORT="${E2E_D3_PORT:-3103}"
+
+c_red()    { printf '\033[31m%s\033[0m\n' "$*"; }
+c_green()  { printf '\033[32m%s\033[0m\n' "$*"; }
+c_blue()   { printf '\033[34m%s\033[0m\n' "$*"; }
+c_yellow() { printf '\033[33m%s\033[0m\n' "$*"; }
+phase() { echo ""; c_blue "━━━ Phase $1: $2 ━━━"; }
+ok()    { c_green "  ✓ $*"; }
+warn()  { c_yellow "  ! $*"; }
+fail()  { c_red "  ✗ FAIL: $*"; FAILED=$((FAILED+1)); }
+
+FAILED=0
+assert_eq() { if [[ "$1" == "$2" ]]; then ok "$3: $1"; else fail "$3: expected '$2', got '$1'"; fi; }
+assert_ge() { if [[ "$1" -ge "$2" ]]; then ok "$3: $1 ≥ $2"; else fail "$3: expected ≥ $2, got $1"; fi; }
+assert_gt() { if [[ "$1" -gt "$2" ]]; then ok "$3: $1 > $2"; else fail "$3: expected > $2, got $1"; fi; }
+
+if [[ "${1:-}" == "docker" ]]; then
+  IMAGE="ework-aio:router-e2e"
+  SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+  echo "Building Docker image $IMAGE..."
+  docker build -f "$SCRIPT_DIR/../Dockerfile.regression" -t "$IMAGE" "$SCRIPT_DIR/.."
+  echo "Running router E2E (npm tag: $NPM_TAG)..."
+  docker run --rm --network host \
+    -e NPM_TAG="$NPM_TAG" \
+    -v "$SCRIPT_DIR/e2e-router.sh:/e2e-router.sh:ro" \
+    -v "$SCRIPT_DIR/fake-llm-server.ts:/fake-llm-server.ts:ro" \
+    "$IMAGE" \
+    bash -c "npm install -g ework-aio@\"\$NPM_TAG\" 2>/dev/null && bash /e2e-router.sh local"
+  exit $?
+fi
+
+echo "╔════════════════════════════════════════════╗"
+echo "║  e2e-router.sh — Multi-daemon routing E2E  ║"
+echo "║  Real opencode + fake LLM + 3 daemons      ║"
+echo "╚════════════════════════════════════════════╝"
+
+phase 0 "Bootstrap (fake LLM + opencode config + services)"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+ework-aio stop 2>/dev/null || true
+ework-aio stop --data-dir "$DATA_DIR" 2>/dev/null || true
+sleep 2
+
+bun run "${SCRIPT_DIR}/fake-llm-server.ts" 2>/tmp/e2e-fakellm.log &
+FAKE_LLM_PID=$!
+sleep 1
+if curl -sf "http://127.0.0.1:$FAKE_LLM_PORT/v1/models" >/dev/null 2>&1; then
+  ok "fake LLM on :$FAKE_LLM_PORT (pid $FAKE_LLM_PID)"
+else
+  fail "fake LLM not responding"; cat /tmp/e2e-fakellm.log; exit 1
+fi
+
+FAKE_XDG="$FAKE_HOME/.config"
+rm -rf "$FAKE_HOME"
+mkdir -p "$FAKE_XDG/opencode"
+cat > "$FAKE_XDG/opencode/opencode.json" <<OCJSON
+{
+  "\$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-ework@latest"],
+  "provider": {
+    "fake": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Fake (E2E)",
+      "options": { "baseURL": "http://127.0.0.1:$FAKE_LLM_PORT/v1" },
+      "models": { "fake-model": { "name": "Fake Model" } }
+    }
+  },
+  "model": "fake/fake-model",
+  "permission": { "reply": "allow", "bash": "allow" }
+}
+OCJSON
+ok "opencode config with fake provider"
+
+export XDG_CONFIG_HOME="$FAKE_XDG"
+OC_BIN="${OPENCODE_BINARY:-$(which opencode 2>/dev/null || echo /usr/local/bin/opencode)}"
+timeout 120 "$OC_BIN" session list </dev/null >/dev/null 2>&1 || true
+ok "opencode warmed up ($OC_BIN)"
+
+rm -rf "$DATA_DIR"
+mkdir -p "$DATA_DIR"
+rm -f "$DATA_DIR/bot-token"
+
+ework-aio install --yes --allow-root \
+  --data-dir "$DATA_DIR" \
+  --port "$WEB_PORT" \
+  --daemon-port "$D1_PORT" 2>&1 | tail -5
+
+sleep 5
+[[ "$(curl -sf http://127.0.0.1:$WEB_PORT/healthz 2>/dev/null || echo FAIL)" != "FAIL" ]] \
+  && ok "web on :$WEB_PORT" || { fail "web not responding"; exit 1; }
+[[ "$(curl -sf http://127.0.0.1:$ROUTER_PORT/api/health 2>/dev/null || echo FAIL)" != "FAIL" ]] \
+  && ok "router on :$ROUTER_PORT" || { fail "router not responding"; exit 1; }
+
+WORK_TOKEN=$(grep WORK_TOKEN "$DATA_DIR/ework-web/.env" | cut -d= -f2)
+COOKIE_SECRET=$(grep WORK_COOKIE_SECRET "$DATA_DIR/ework-web/.env" | cut -d= -f2)
+BOT_TOKEN=$(cat "$DATA_DIR/bot-token" 2>/dev/null || echo "")
+
+AUTH_COOKIE=$(node -e "
+const crypto = require('crypto');
+const now = Math.floor(Date.now()/1000);
+const msg = 'v2.dog.' + now;
+console.log(msg + '.' + crypto.createHmac('sha256', '$COOKIE_SECRET').update(msg).digest('base64url'));
+")
+
+ework-aio add-daemon "$D2_PORT" --data-dir "$DATA_DIR" --allow-root -y 2>&1 | tail -2
+sleep 2
+ework-aio add-daemon "$D3_PORT" --data-dir "$DATA_DIR" --allow-root -y 2>&1 | tail -2
+sleep 5
+
+DAEMON_DB="$DATA_DIR/ework-daemon/ework-daemon.db"
+DAEMON_COUNT=$(sqlite3 "$DAEMON_DB" "SELECT COUNT(*) FROM daemons WHERE status='active';" 2>/dev/null || echo 0)
+assert_ge "$DAEMON_COUNT" 3 "daemons registered in DB"
+
+phase 1 "Project + webhook → router"
+LOC=$(curl -s -o /dev/null -D - -X POST \
+  -H "Cookie: ework_auth=$AUTH_COOKIE" \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  -d "title=bootstrap&body=init" \
+  "http://127.0.0.1:$WEB_PORT/e2e/router-test/issues/new" 2>/dev/null \
+  | grep -i '^location:' | tr -d '\r' | awk '{print $2}')
+[[ -n "$LOC" ]] && ok "project+issue created" || { fail "issue creation failed"; exit 1; }
+sleep 8
+
+ROUTER_LOG="$DATA_DIR/run/router.log"
+ROUTE_BEFORE=$(grep -c '"routing"' "$ROUTER_LOG" 2>/dev/null || echo 0)
+assert_gt "$ROUTE_BEFORE" 0 "router routed bootstrap issue"
+
+phase 2 "Least-loaded distribution (3 issues)"
+create_issue() {
+  curl -s -o /dev/null -D - -X POST \
+    -H "Cookie: ework_auth=$AUTH_COOKIE" \
+    -H "Content-Type: application/x-www-form-urlencoded" \
+    -d "title=$1&body=$2" \
+    "http://127.0.0.1:$WEB_PORT/e2e/router-test/issues/new" 2>/dev/null \
+    | grep -i '^location:' | tr -d '\r' | awk '{print $2}' | grep -oP '\d+$'
+}
+
+ISSUE1=$(create_issue "route-1" "test")
+ISSUE2=$(create_issue "route-2" "test")
+ISSUE3=$(create_issue "route-3" "test")
+assert_gt "${#ISSUE1}" 0 0 "issue-1 (#$ISSUE1)"
+assert_gt "${#ISSUE2}" 0 0 "issue-2 (#$ISSUE2)"
+assert_gt "${#ISSUE3}" 0 0 "issue-3 (#$ISSUE3)"
+
+sleep 15
+
+ROUTE_AFTER=$(grep -c '"routing"' "$ROUTER_LOG" 2>/dev/null || echo 0)
+NEW_ROUTES=$((ROUTE_AFTER - ROUTE_BEFORE))
+assert_ge "$NEW_ROUTES" 3 "≥3 routing decisions"
+
+D1_HITS=$(grep '"routing"' "$ROUTER_LOG" | grep -c "127.0.0.1:$D1_PORT" || echo 0)
+D2_HITS=$(grep '"routing"' "$ROUTER_LOG" | grep -c "127.0.0.1:$D2_PORT" || echo 0)
+D3_HITS=$(grep '"routing"' "$ROUTER_LOG" | grep -c "127.0.0.1:$D3_PORT" || echo 0)
+echo "  distribution: d1=$D1_HITS d2=$D2_HITS d3=$D3_HITS"
+
+UNIQUE=0
+[[ $D1_HITS -gt 0 ]] && UNIQUE=$((UNIQUE+1))
+[[ $D2_HITS -gt 0 ]] && UNIQUE=$((UNIQUE+1))
+[[ $D3_HITS -gt 0 ]] && UNIQUE=$((UNIQUE+1))
+assert_ge "$UNIQUE" 2 "≥2 unique daemons used"
+
+phase 3 "[bot] replies via real opencode + fake LLM"
+for n in $ISSUE1 $ISSUE2 $ISSUE3; do
+  REPLIES=$(curl -sf -H "Authorization: token $BOT_TOKEN" \
+    "http://127.0.0.1:$WEB_PORT/api/v1/repos/e2e/router-test/issues/$n/comments" 2>/dev/null \
+    | jq -r '[.[] | select(.body | startswith("[bot]"))] | length' 2>/dev/null || echo 0)
+  assert_ge "$REPLIES" 1 "issue #$n has ≥1 [bot] reply"
+done
+
+phase 4 "Close → re-route"
+curl -sf -X PATCH -H "Authorization: token $BOT_TOKEN" \
+  -H "Content-Type: application/json" -d '{"state":"closed"}' \
+  "http://127.0.0.1:$WEB_PORT/api/v1/repos/e2e/router-test/issues/$ISSUE1" >/dev/null 2>&1
+sleep 3
+ISSUE4=$(create_issue "route-4-after-close" "test")
+assert_gt "${#ISSUE4}" 0 0 "issue-4 (#$ISSUE4)"
+sleep 10
+FINAL_ROUTES=$(grep -c '"routing"' "$ROUTER_LOG" 2>/dev/null || echo 0)
+assert_gt "$FINAL_ROUTES" "$ROUTE_AFTER" "new route after issue-4"
+
+phase 5 "Failover (kill daemon-2)"
+D2_PID=$(cat "$DATA_DIR/run/daemon-2.pid" 2>/dev/null || echo "")
+if [[ -n "$D2_PID" ]] && kill -0 "$D2_PID" 2>/dev/null; then
+  kill "$D2_PID" 2>/dev/null || true
+  ok "daemon-2 killed (pid $D2_PID)"
+  sleep 3
+  ISSUE5=$(create_issue "route-5-failover" "test")
+  assert_gt "${#ISSUE5}" 0 0 "issue-5 (#$ISSUE5)"
+  sleep 10
+  POST_KILL_D2=$(grep '"routing"' "$ROUTER_LOG" | tail -5 \
+    | grep -c "127.0.0.1:$D2_PORT" || echo 0)
+  assert_eq "$POST_KILL_D2" 0 "no routes to dead daemon-2"
+else
+  warn "daemon-2 not running, skipping failover"
+fi
+
+phase 6 "Webhook delivery audit"
+WEB_DB="$DATA_DIR/ework-web/ework-web.db"
+if [[ -f "$WEB_DB" ]]; then
+  DELIVERIES=$(sqlite3 "$WEB_DB" \
+    "SELECT COUNT(*) FROM webhook_deliveries WHERE status_code >= 200 AND status_code < 300;" \
+    2>/dev/null || echo 0)
+  assert_ge "$DELIVERIES" 3 "≥3 successful webhook deliveries"
+else
+  warn "web DB not found"
+fi
+
+echo ""
+echo "════════════════════════════════════════════"
+if [[ $FAILED -eq 0 ]]; then
+  c_green "✅ ALL ROUTER E2E PHASES PASSED"
+else
+  c_red "❌ $FAILED ASSERTION(S) FAILED"
+fi
+echo "════════════════════════════════════════════"
+
+kill "$FAKE_LLM_PID" 2>/dev/null || true
+[[ "${KEEP_ALIVE:-0}" != "1" ]] && ework-aio stop 2>/dev/null || true
+exit $FAILED

package/scripts/fake-llm-server.ts

@@ -1,350 +1,112 @@
 #!/usr/bin/env bun
-// Fake OpenAI-compatible LLM server for E2E tests.
-//
-// Listens on 127.0.0.1:PORT and responds to /v1/chat/completions with a
-// deterministic, context-aware canned reply. Used by the docker E2E test
-// to drive real `opencode run` against a stub LLM — opencode can't tell
-// the difference, writes a real session to opencode.db, and awork-web can
-// then render that session via its normal /sessions/:id route.
-//
-// Why not just stub the opencode binary? Because awork-web reads opencode.db
-// directly (src/opencode.ts:98-139 listSessions) and calls `opencode export`
-// for transcripts — stubbing the binary means re-implementing the SQLite
-// schema, which would silently drift from real opencode. Talking to a fake
-// LLM exercises every piece except the network call to a real model.
-//
-// Usage:
-//   PORT=8400 bun run scripts/fake-llm-server.ts
-//   # or just: bun run scripts/fake-llm-server.ts  (defaults to 8400)
-
-const PORT = parseInt(process.env.PORT ?? "8400", 10);
-const HOST = process.env.HOST ?? "127.0.0.1";
+const PORT = Number(process.env.FAKE_LLM_PORT ?? 8401);
+const HOST = process.env.FAKE_LLM_HOST ?? "127.0.0.1";
 
 const server = Bun.serve({
   port: PORT,
   hostname: HOST,
   fetch(req) {
     const url = new URL(req.url);
-    log(`${req.method} ${url.pathname}`);
 
-    if (req.method === "GET" && url.pathname === "/v1/models") {
-      return json({
+    if (url.pathname === "/v1/models" && req.method === "GET") {
+      return Response.json({
         object: "list",
-        data: [
-          {
-            id: "fake-model",
-            object: "model",
-            created: 1_700_000_000_000,
-            owned_by: "e2e-test",
-          },
-        ],
+        data: [{
+          id: "fake/fake-model",
+          object: "model",
+          created: Math.floor(Date.now() / 1000),
+          owned_by: "e2e",
+        }],
       });
     }
 
-    if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+    if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
       return handleChatCompletion(req);
     }
 
-    return json({ error: `not found: ${req.method} ${url.pathname}` }, 404);
+    return new Response("Not found", { status: 404 });
   },
 });
 
-function log(msg: string): void {
-  process.stderr.write(`[fake-llm] ${new Date().toISOString()} ${msg}\n`);
-}
-
-function json(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "content-type": "application/json",
-      "access-control-allow-origin": "*",
-    },
-  });
-}
-
 async function handleChatCompletion(req: Request): Promise<Response> {
-  let body: any;
-  try {
-    body = await req.json();
-  } catch (err) {
-    return json({ error: `invalid JSON: ${(err as Error).message}` }, 400);
-  }
-
-  // Log the full request so we can see what opencode/@ai-sdk is asking for
-  // (stream vs non-stream, tool definitions, system prompt, etc).
-  log(`  body: stream=${body?.stream} model=${body?.model} msgs=${body?.messages?.length} tools=${body?.tools?.length ?? 0}`);
-
-  const messages = Array.isArray(body?.messages) ? body.messages : [];
-  const tools = Array.isArray(body?.tools) ? body.tools : [];
-  const lastMsg = messages[messages.length - 1];
-  const lastRole = lastMsg?.role;
-  const userMsgs = messages.filter((m: any) => m?.role === "user");
-  const lastUser = userMsgs[userMsgs.length - 1];
-  const userText = typeof lastUser?.content === "string"
-    ? lastUser.content
-    : Array.isArray(lastUser?.content)
-      ? lastUser.content.map((p: any) => p?.text ?? "").join(" ")
-      : "";
-
-  const hasReplyTool = tools.some((t: any) => t?.function?.name === "reply");
-
-  // Tool-call path: when `reply` is registered and the last message is the
-  // user's initial prompt (not a tool_result), emit a tool_use so opencode
-  // actually invokes the reply tool → ework-web posts a [bot] comment on the
-  // issue. Without this the daemon only posts its [system] "picked up"
-  // notification and the LLM-driven auto-reply loop never fires.
-  //
-  // After opencode executes the tool it makes a follow-up call with
-  // role=tool in the messages — at that point we drop back to text.
-  if (hasReplyTool && lastRole === "user") {
-    const ref = parseIssueRef(userText);
-    if (ref) {
-      log(`  emitting reply tool_use → ${ref.owner}/${ref.repo}#${ref.number}`);
-      const toolReplyBody =
-        `[bot] E2E fake-LLM auto-reply.\n\n` +
-        `Picked up ${ref.owner}/${ref.repo}#${ref.number}. ` +
-        `This is a stub reply emitted by scripts/fake-llm-server.ts to exercise ` +
-        `the opencode-ework \`reply\` tool end-to-end. The real value of this ` +
-        `test is that opencode received a tool_use, executed the reply tool, ` +
-        `and ework-web posted this comment as ${process.env.BOT_USERNAME ?? "bot"}.`;
-      return toolCallResponse(body?.model ?? "fake-model", "reply", {
-        owner: ref.owner,
-        repo: ref.repo,
-        number: ref.number,
-        body: toolReplyBody,
-      }, body?.stream === true);
-    }
-  }
-
-  // Deterministic, context-aware reply: echo a snippet of the user's last
-  // message so the session transcript has traceable content (not just a
-  // fixed string). Truncated so the reply stays readable in the UI.
-  const snippet = userText.slice(0, 120).replace(/\s+/g, " ").trim();
-  const reply =
-    `E2E fake-LLM reply.\n\n` +
-    `You said: "${snippet}${userText.length > 120 ? "…" : ""}"\n\n` +
-    `This is a stub response from scripts/fake-llm-server.ts. ` +
-    `The real value of this test is that opencode wrote a real session row ` +
-    `to opencode.db and awork-web can render it end-to-end.`;
-
-  const promptTokens = roughTokens(JSON.stringify(messages));
-  const completionTokens = roughTokens(reply);
-  const usage = {
-    prompt_tokens: promptTokens,
-    completion_tokens: completionTokens,
-    total_tokens: promptTokens + completionTokens,
+  const body = await req.json() as {
+    model?: string;
+    messages?: Array<{ role: string; content: unknown }>;
+    tools?: Array<unknown>;
+    stream?: boolean;
   };
 
-  // opencode (@ai-sdk/openai-compatible) defaults to stream=true. Returning
-  // a non-streaming JSON response silently produces a 0-token session row
-  // with no assistant text — the request completes but the transcript is
-  // empty. Honor the stream flag and emit SSE chunks.
-  if (body?.stream === true) {
-    return streamResponse(body?.model ?? "fake-model", reply, usage);
-  }
+  const model = body.model ?? "fake/fake-model";
+  const isStream = body.stream ?? false;
+  const hasTools = (body.tools?.length ?? 0) > 0;
 
-  // Non-streaming path (used by curl sanity checks in tests).
-  return json({
-    id: `chatcmpl-fake-${crypto.randomUUID()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1000),
-    model: body?.model ?? "fake-model",
-    choices: [
-      {
-        index: 0,
-        message: { role: "assistant", content: reply },
-        finish_reason: "stop",
-      },
-    ],
-    usage,
-  });
-}
-
-// Parse an issue ref of the form `<owner>/<repo>#<n>` out of arbitrary text
-// (typically the user prompt built by ework-daemon's buildInitialPrompt,
-// which includes "(gitea:owner/repo#N)"). Returns null if no match.
-function parseIssueRef(text: string): { owner: string; repo: string; number: number } | null {
-  const m = text.match(/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)/);
-  if (!m) return null;
-  const [, owner, repo, num] = m;
-  const number = parseInt(num, 10);
-  if (!Number.isFinite(number)) return null;
-  return { owner, repo, number };
-}
+  if (!hasTools) {
+    return textResponse(model, "Acknowledged.", isStream);
+  }
 
-// Emit a tool_use response (OpenAI function-calling format). Supports both
-// streaming and non-streaming because opencode defaults to stream=true but
-// curl smoke tests use non-streaming.
-function toolCallResponse(model: string, toolName: string, args: Record<string, unknown>, stream: boolean): Response {
-  const id = `chatcmpl-fake-${crypto.randomUUID()}`;
-  const created = Math.floor(Date.now() / 1000);
   const callId = `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
-  const argsJson = JSON.stringify(args);
-  const usage = {
-    prompt_tokens: roughTokens(argsJson),
-    completion_tokens: roughTokens(argsJson),
-    total_tokens: roughTokens(argsJson) * 2,
-  };
+  const replyBody = JSON.stringify({ body: "[bot] Processed by fake LLM" });
 
-  if (!stream) {
-    return json({
-      id,
+  if (!isStream) {
+    return Response.json({
+      id: `chatcmpl-fake-${crypto.randomUUID()}`,
       object: "chat.completion",
-      created,
+      created: Math.floor(Date.now() / 1000),
       model,
-      choices: [
-        {
-          index: 0,
-          message: {
-            role: "assistant",
-            content: null,
-            tool_calls: [
-              {
-                id: callId,
-                type: "function",
-                function: { name: toolName, arguments: argsJson },
-              },
-            ],
-          },
-          finish_reason: "tool_calls",
+      choices: [{
+        index: 0,
+        message: {
+          role: "assistant",
+          content: null,
+          tool_calls: [{
+            id: callId,
+            type: "function",
+            function: { name: "reply", arguments: replyBody },
+          }],
         },
-      ],
-      usage,
+        finish_reason: "tool_calls",
+      }],
+      usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
     });
   }
 
   const encoder = new TextEncoder();
+  const id = `chatcmpl-fake-${crypto.randomUUID()}`;
+  const created = Math.floor(Date.now() / 1000);
+
   const readable = new ReadableStream({
     start(controller) {
-      // Initial chunk: declare the tool_call with name + empty arguments.
-      controller.enqueue(
-        encoder.encode(
-          sseLine({
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{
-              index: 0,
-              delta: {
-                role: "assistant",
-                content: null,
-                tool_calls: [{
-                  index: 0,
-                  id: callId,
-                  type: "function",
-                  function: { name: toolName, arguments: "" },
-                }],
-              },
-              finish_reason: null,
-            }],
-          }),
-        ),
-      );
-      // Arguments chunk: full JSON in one shot (splitting is optional).
-      controller.enqueue(
-        encoder.encode(
-          sseLine({
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{
-              index: 0,
-              delta: {
-                tool_calls: [{ index: 0, function: { arguments: argsJson } }],
-              },
-              finish_reason: null,
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+        id, object: "chat.completion.chunk", created, model,
+        choices: [{
+          index: 0,
+          delta: {
+            role: "assistant",
+            content: null,
+            tool_calls: [{
+              index: 0, id: callId, type: "function",
+              function: { name: "reply", arguments: "" },
             }],
-          }),
-        ),
-      );
-      // Final chunk: finish_reason + usage.
-      controller.enqueue(
-        encoder.encode(
-          sseLine({
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
-            usage,
-          }),
-        ),
-      );
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-      controller.close();
-    },
-  });
-
-  return new Response(readable, {
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      "connection": "keep-alive",
-      "access-control-allow-origin": "*",
-    },
-  });
-}
+          },
+          finish_reason: null,
+        }],
+      })}\n\n`));
 
-function streamResponse(model: string, reply: string, usage: any): Response {
-  const id = `chatcmpl-fake-${crypto.randomUUID()}`;
-  const created = Math.floor(Date.now() / 1000);
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+        id, object: "chat.completion.chunk", created, model,
+        choices: [{
+          index: 0,
+          delta: { tool_calls: [{ index: 0, function: { arguments: replyBody } }] },
+          finish_reason: null,
+        }],
+      })}\n\n`));
 
-  // Split into ~10 chunks so the streaming code path actually streams
-  // (single-chunk streams work but look unrealistic in logs).
-  const chunks: string[] = [];
-  const words = reply.split(/(\s+)/);
-  const perChunk = Math.max(1, Math.ceil(words.length / 10));
-  for (let i = 0; i < words.length; i += perChunk) {
-    chunks.push(words.slice(i, i + perChunk).join(""));
-  }
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+        id, object: "chat.completion.chunk", created, model,
+        choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+      })}\n\n`));
 
-  const encoder = new TextEncoder();
-  const readable = new ReadableStream({
-    start(controller) {
-      // First chunk: role + opening content.
-      controller.enqueue(
-        encoder.encode(
-          sseLine({
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{ index: 0, delta: { role: "assistant", content: chunks[0] ?? "" }, finish_reason: null }],
-          }),
-        ),
-      );
-      // Subsequent chunks: content deltas only.
-      for (let i = 1; i < chunks.length; i++) {
-        controller.enqueue(
-          encoder.encode(
-            sseLine({
-              id,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{ index: 0, delta: { content: chunks[i] }, finish_reason: null }],
-            }),
-          ),
-        );
-      }
-      // Final chunk: empty delta + finish_reason + usage (usage must be on
-      // the final chunk when stream_options.include_usage is set; opencode
-      // sets it so the session row gets non-zero token counts).
-      controller.enqueue(
-        encoder.encode(
-          sseLine({
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-            usage,
-          }),
-        ),
-      );
       controller.enqueue(encoder.encode("data: [DONE]\n\n"));
       controller.close();
     },
@@ -354,28 +116,29 @@ function streamResponse(model: string, reply: string, usage: any): Response {
     headers: {
       "content-type": "text/event-stream",
       "cache-control": "no-cache",
-      "connection": "keep-alive",
-      "access-control-allow-origin": "*",
+      connection: "keep-alive",
     },
   });
 }
 
-function sseLine(obj: any): string {
-  return `data: ${JSON.stringify(obj)}\n\n`;
-}
-
-function roughTokens(text: string): number {
-  // Crude 4-chars-per-token heuristic. Token counts only need to be >0 for
-  // awork-web's heat bar (which divides by max-peak-token across the session).
-  // Real tokenizer isn't needed for test data.
-  return Math.max(1, Math.ceil(text.length / 4));
+function textResponse(model: string, text: string, isStream: boolean): Response {
+  if (!isStream) {
+    return Response.json({
+      id: `chatcmpl-fake-${crypto.randomUUID()}`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model,
+      choices: [{
+        index: 0,
+        message: { role: "assistant", content: text },
+        finish_reason: "stop",
+      }],
+      usage: { prompt_tokens: 5, completion_tokens: 5, total_tokens: 10 },
+    });
+  }
+  return new Response("data: [DONE]\n\n", {
+    headers: { "content-type": "text/event-stream" },
+  });
 }
 
-process.stderr.write(
-  `[fake-llm] listening on http://${HOST}:${PORT}\n` +
-    `[fake-llm] POST /v1/chat/completions  -> canned OpenAI response\n` +
-    `[fake-llm] GET  /v1/models           -> { fake-model }\n`,
-);
-
-// Keep stderr unbuffered so logs show up immediately in docker output.
-process.stderr.write(`[fake-llm] ready (pid ${process.pid})\n`);
+process.stderr.write(`[fake-llm] listening on http://${HOST}:${PORT}\n`);

package/scripts/mock-opencode.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# mock-opencode: Drop-in replacement for `opencode run` in E2E tests.
+#
+# The daemon spawns: opencode run --format json --dir <workdir> [--session <id>] [--model <m>] "<prompt>"
+# This mock:
+#   1. Emits {"sessionID":"ses_mock_<ts>_<pid>"} to stdout (what the daemon parses)
+#   2. Parses the prompt to extract issue ref (owner/repo#number)
+#   3. Posts a [bot] reply via the Gitea API so finishRun sees a recent bot reply (no nudging)
+#   4. Exits 0
+#
+# Env vars used: GITEA_URL, BOT_TOKEN (both set by the daemon's child env)
+set -euo pipefail
+
+PROMPT=""
+WORKDIR=""
+SESSION_ID=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    run) shift ;;
+    --format) shift ;;
+    json) shift ;;
+    --dir) WORKDIR="$2"; shift 2 ;;
+    --session) SESSION_ID="$2"; shift 2 ;;
+    --model) shift 2 ;;
+    *) PROMPT="$1"; shift ;;
+  esac
+done
+
+# Emit session ID JSON (daemon reads this from stdout)
+SID="ses_mock_$(date +%s)_$$"
+echo "{\"sessionID\":\"$SID\"}"
+
+# Try to extract issue ref from the prompt text
+# Format 1 (initial):   - Issue: "title" (gitea:owner/repo#number)
+# Format 2 (forward):    posted a new comment on owner/repo#number
+ISSUE_REF=""
+if echo "$PROMPT" | grep -qoP 'Issue:.*?\([\w:]+([\w.-]+/[\w.-]+#\d+)\)' 2>/dev/null; then
+  ISSUE_REF=$(echo "$PROMPT" | grep -oP 'Issue:.*?\([\w:]+([\w.-]+/[\w.-]+#\d+)\)' | grep -oP '[\w.-]+/[\w.-]+#\d+' | head -1)
+elif echo "$PROMPT" | grep -qoP 'comment on ([\w.-]+/[\w.-]+#\d+)' 2>/dev/null; then
+  ISSUE_REF=$(echo "$PROMPT" | grep -oP 'comment on ([\w.-]+/[\w.-]+#\d+)' | grep -oP '[\w.-]+/[\w.-]+#\d+' | head -1)
+fi
+
+if [[ -z "$ISSUE_REF" || -z "${GITEA_URL:-}" || -z "${BOT_TOKEN:-}" ]]; then
+  # Can't post a reply — daemon will nudge, but that's fine for routing tests
+  sleep 0.5
+  exit 0
+fi
+
+OWNER=$(echo "$ISSUE_REF" | cut -d'#' -f1 | cut -d'/' -f1)
+REPO=$(echo "$ISSUE_REF" | cut -d'#' -f1 | cut -d'/' -f2-)
+NUMBER=$(echo "$ISSUE_REF" | cut -d'#' -f2)
+
+# Simulate work (1s) then post [bot] reply
+sleep 1
+
+curl -sf -X POST \
+  -H "Authorization: token $BOT_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "{\"body\":\"[bot] Mock processed ($OWNER/$REPO#$NUMBER) on $(hostname)\"}" \
+  "${GITEA_URL}/api/v1/repos/${OWNER}/${REPO}/issues/${NUMBER}/comments" \
+  > /dev/null 2>&1 || true
+
+exit 0

package/src/commands/add-daemon.ts

@@ -60,9 +60,15 @@ export async function runAddDaemon(
     const eqIdx = line.indexOf("=");
     if (eqIdx === -1) return line;
     if (line.slice(0, eqIdx).trim().startsWith("#")) return line;
-    if (line.slice(0, eqIdx).trim() === "DAEMON_PORT") {
+    const key = line.slice(0, eqIdx).trim();
+    if (key === "DAEMON_PORT") {
       return `DAEMON_PORT=${newPort}`;
     }
+    if (key === "DAEMON_ENDPOINT") {
+      const oldVal = line.slice(eqIdx + 1).trim();
+      const host = oldVal.split(":")[0] || "127.0.0.1";
+      return `DAEMON_ENDPOINT=${host}:${newPort}`;
+    }
     return line;
   });
   const body = serializeEnvFile(

package/src/config.ts

@@ -104,9 +104,9 @@ export const ROUTER_ENV_KEYS: readonly EnvKeySpec[] = [
   { envVar: "ROUTER_FALLBACK_ENDPOINT", file: "router", generate: (c) => `http://127.0.0.1:${c.daemonPort}` },
   { envVar: "ROUTER_CONFIG_FILE",       file: "router", generate: (c) => `${c.paths.routerDataDir}/strategy.json` },
   { envVar: "WORK_DB_DRIVER",       file: "router", generate: () => "sqlite" },
-  { envVar: "WORK_DB_PATH",         file: "router", generate: (c) => c.paths.webDbPath },
+  { envVar: "WORK_DB_PATH",         file: "router", generate: (c) => c.paths.daemonDbPath },
   { envVar: "WORK_DB_PREFIX",       file: "router", generate: () => "" },
-  { envVar: "DAEMON_TABLE_PREFIX",  file: "router", generate: () => "d_" },
+  { envVar: "DAEMON_TABLE_PREFIX",  file: "router", generate: () => "" },
 ] as const;
 
 export function keysForFile(file: EnvFile): readonly EnvKeySpec[] {