@programinglive/dev-workflow-mcp-server 1.8.1 → 1.10.0

package/scripts/setup-test-dbs.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+#
+# Creates isolated test databases and users on the database host.
+#
+# Run this on bw-server (it uses sudo locally). It creates:
+#   - PostgreSQL database `devworkflow_test` and role `devworkflow_test`
+#   - MySQL database `devworkflow_test` and user `dwftest`
+#
+# It never touches an existing database, and the role is granted access only to
+# its own database. The adapter tests INSERT and UPDATE real rows, so pointing
+# them at a production database would corrupt real history data.
+#
+# Prints the two connection URLs at the end.
+
+set -euo pipefail
+
+PG_DB=devworkflow_test
+PG_USER=devworkflow_test
+PG_PASS="$(openssl rand -hex 16)"
+
+MY_DB=devworkflow_test
+MY_USER=dwftest
+MY_PASS="$(openssl rand -hex 16)"
+
+echo "=== PostgreSQL ==="
+sudo -u postgres psql -v ON_ERROR_STOP=1 <<SQL
+DO \$\$
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname='${PG_USER}') THEN
+    CREATE ROLE ${PG_USER} WITH LOGIN PASSWORD '${PG_PASS}';
+  ELSE
+    ALTER ROLE ${PG_USER} WITH LOGIN PASSWORD '${PG_PASS}';
+  END IF;
+END
+\$\$;
+SQL
+
+sudo -u postgres psql -tAc "SELECT 1 FROM pg_database WHERE datname='${PG_DB}'" | grep -q 1 \
+  || sudo -u postgres createdb -O "${PG_USER}" "${PG_DB}"
+
+sudo -u postgres psql -d "${PG_DB}" -c "GRANT ALL ON SCHEMA public TO ${PG_USER};" > /dev/null
+sudo -u postgres psql -d "${PG_DB}" -c "ALTER SCHEMA public OWNER TO ${PG_USER};" > /dev/null
+
+echo "=== MySQL ==="
+sudo mysql <<SQL
+CREATE DATABASE IF NOT EXISTS \`${MY_DB}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+CREATE USER IF NOT EXISTS '${MY_USER}'@'localhost' IDENTIFIED BY '${MY_PASS}';
+ALTER USER '${MY_USER}'@'localhost' IDENTIFIED BY '${MY_PASS}';
+GRANT ALL PRIVILEGES ON \`${MY_DB}\`.* TO '${MY_USER}'@'localhost';
+FLUSH PRIVILEGES;
+SQL
+
+echo "=== verification ==="
+mysql -h 127.0.0.1 -u "${MY_USER}" -p"${MY_PASS}" -N -B -e "SELECT 'mysql ok'" "${MY_DB}"
+
+echo
+echo "Add these to your shell before running scripts/test-db-adapters.sh"
+echo "(ports are the local tunnel ports):"
+echo
+echo "TEST_POSTGRES_URL=postgresql://${PG_USER}:${PG_PASS}@127.0.0.1:15432/${PG_DB}"
+echo "TEST_MYSQL_URL=mysql://${MY_USER}:${MY_PASS}@127.0.0.1:13306/${MY_DB}"

package/scripts/test-db-adapters.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+#
+# Runs the database adapter tests against real MySQL and PostgreSQL.
+#
+# The two adapters are skipped in the default suite because they need a live
+# database. This script opens an SSH tunnel to bw-server (where both servers
+# run on localhost), runs only the adapter tests, and closes the tunnel.
+#
+# Usage:
+#   ./scripts/test-db-adapters.sh
+#
+# Requires:
+#   - an SSH host alias `bw-tunnel` that can reach 127.0.0.1:3306 and :5432
+#     (see ~/.ssh/config; the restricted dbtunnel account is enough)
+#   - TEST_MYSQL_URL / TEST_POSTGRES_URL pointing at the forwarded ports,
+#     or the defaults below
+#
+# The test databases are created by scripts/setup-test-dbs.sh on the server.
+# Tests write real rows, so never point these at a production database.
+
+set -euo pipefail
+
+LOCAL_PG_PORT="${LOCAL_PG_PORT:-15432}"
+LOCAL_MY_PORT="${LOCAL_MY_PORT:-13306}"
+SSH_HOST="${SSH_HOST:-bw-tunnel}"
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+if ! command -v ssh > /dev/null 2>&1; then
+  echo "ssh not found; this script needs an SSH tunnel to the database host." >&2
+  exit 1
+fi
+
+cleanup() {
+  if [ -n "${TUNNEL_PID:-}" ] && kill -0 "$TUNNEL_PID" 2> /dev/null; then
+    kill "$TUNNEL_PID" 2> /dev/null || true
+    wait "$TUNNEL_PID" 2> /dev/null || true
+    echo "tunnel closed"
+  fi
+}
+trap cleanup EXIT
+
+echo "opening tunnel to $SSH_HOST ($LOCAL_PG_PORT -> 5432, $LOCAL_MY_PORT -> 3306)"
+ssh -o BatchMode=yes -o ExitOnForwardFailure=yes -N \
+  -L "${LOCAL_PG_PORT}:127.0.0.1:5432" \
+  -L "${LOCAL_MY_PORT}:127.0.0.1:3306" \
+  "$SSH_HOST" &
+TUNNEL_PID=$!
+
+# Wait for the forwards to accept connections.
+for port in "$LOCAL_PG_PORT" "$LOCAL_MY_PORT"; do
+  ready=0
+  for _ in $(seq 1 20); do
+    if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2> /dev/null; then
+      exec 3>&- 3<&-
+      ready=1
+      break
+    fi
+    sleep 0.5
+  done
+  if [ "$ready" -ne 1 ]; then
+    echo "port $port did not open; is $SSH_HOST reachable?" >&2
+    exit 1
+  fi
+done
+
+: "${TEST_POSTGRES_URL:?set TEST_POSTGRES_URL (see scripts/setup-test-dbs.sh)}"
+: "${TEST_MYSQL_URL:?set TEST_MYSQL_URL (see scripts/setup-test-dbs.sh)}"
+
+cd "$REPO_ROOT"
+node --no-deprecation --test tests/db-adapters.test.js

package/scripts/verify-bundle.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Verifies that the built bundle actually starts.
+ *
+ * `npm run build:server` succeeding only means the bundler emitted a file. It
+ * says nothing about whether that file runs. This bit us with vite 8: the build
+ * was green and smaller, but `node dist/index.mjs` threw
+ *
+ *   Calling `require` for "fs" in an environment that doesn't expose the
+ *   `require` function
+ *
+ * because rolldown's CJS shim assumed CommonJS. CI only ran the build, so a
+ * broken artefact would have shipped.
+ *
+ * The MCP server is a stdio server: it exits cleanly when stdin closes. So the
+ * pass condition is the startup banner, not the exit code - the same rule used
+ * by scripts/setup-stack.js and the release workflow.
+ *
+ * Usage: node scripts/verify-bundle.mjs [dist/index.mjs]
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+const entry = path.resolve(process.argv[2] || 'dist/index.mjs');
+const STARTUP_PATTERN = /running on stdio|MCP Server starting/i;
+const TIMEOUT_MS = 15000;
+
+if (!existsSync(entry)) {
+  console.error(`✖ Bundle not found: ${entry}`);
+  console.error('  Run "npm run build:server" first.');
+  process.exit(1);
+}
+
+console.log(`Verifying ${path.relative(process.cwd(), entry)}`);
+
+const child = spawn(process.execPath, [entry], {
+  stdio: ['pipe', 'pipe', 'pipe'],
+});
+
+let stdout = '';
+let stderr = '';
+let settled = false;
+
+child.stdout.on('data', (chunk) => {
+  stdout += chunk.toString();
+});
+child.stderr.on('data', (chunk) => {
+  stderr += chunk.toString();
+});
+
+function finish(ok, reason) {
+  if (settled) return;
+  settled = true;
+  clearTimeout(timer);
+  try {
+    child.kill();
+  } catch {
+    // already gone
+  }
+
+  const output = `${stdout}${stderr}`;
+  if (ok) {
+    console.log(`✓ ${reason}`);
+    process.exit(0);
+  }
+
+  console.error(`✖ ${reason}`);
+  console.error('--- bundle output ---');
+  console.error(output.trim() || '(no output)');
+  process.exit(1);
+}
+
+child.on('error', (error) => finish(false, `Failed to spawn: ${error.message}`));
+
+child.on('exit', (code) => {
+  if (STARTUP_PATTERN.test(`${stdout}${stderr}`)) {
+    finish(true, 'Bundle started and exited cleanly (stdin closed).');
+  } else {
+    finish(false, `Bundle exited with code ${code} without reporting that it started.`);
+  }
+});
+
+const timer = setTimeout(() => {
+  if (STARTUP_PATTERN.test(`${stdout}${stderr}`)) {
+    finish(true, 'Bundle started and stayed alive.');
+  } else {
+    finish(false, `Bundle produced no startup output within ${TIMEOUT_MS}ms.`);
+  }
+}, TIMEOUT_MS);

package/tools/definitions.js

@@ -35,6 +35,25 @@ export function getToolList() {
         required: ["summary"],
       },
     },
+    {
+      name: "create_feature_flow",
+      description:
+        "Record the feature flow using Mermaid syntax. This helps visualize the implementation plan.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          mermaidCode: {
+            type: "string",
+            description: "The Mermaid code representing the feature flow",
+          },
+          description: {
+            type: "string",
+            description: "A brief description of this flow",
+          },
+        },
+        required: ["mermaidCode", "description"],
+      },
+    },
     {
       name: "create_tests",
       description: "Mark that tests covering the change have been created.",
@@ -343,5 +362,129 @@ export function getToolList() {
         properties: {},
       },
     },
+    {
+      name: "list_factory_tasks",
+      description:
+        "List tasks from the Factory board (factory.programinglive.com), newest activity first. Defaults to work that still needs attention: running, queued, backlog, review and blocked. Requires FACTORY_URL plus FACTORY_TOKEN, or FACTORY_EMAIL and FACTORY_PASSWORD.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          statuses: {
+            type: "array",
+            items: { type: "string", enum: ["backlog", "queued", "running", "review", "blocked", "done", "cancelled"] },
+            description: "Statuses to include. Defaults to running, queued, backlog, review and blocked.",
+          },
+          project: {
+            type: "string",
+            description: "Optional project name or id to filter by (case-insensitive substring).",
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of tasks to return (1-200, default 50).",
+          },
+        },
+      },
+    },
+    {
+      name: "list_factory_projects",
+      description:
+        "List projects in the Factory workspace with their UUIDs. Run this before create_factory_task, because Factory requires a real projectId and cannot accept an invented one.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
+    {
+      name: "create_factory_task",
+      description:
+        "Create a task on the Factory board through the official write path (POST /api/factory create_task). Defaults to status 'backlog', which records the work WITHOUT starting a worker run. Only pass status 'queued' when you really want the worker to execute it - Factory rejects a queued task (409) unless 'acceptance' contains a ```run block. Use list_factory_projects first to get a real projectId.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: {
+            type: "string",
+            description: "Project UUID from list_factory_projects. Required.",
+          },
+          title: {
+            type: "string",
+            description: "Task title, 3-140 characters.",
+          },
+          description: {
+            type: "string",
+            description: "Optional context: current behaviour, what should change. Max 4000 characters.",
+          },
+          acceptance: {
+            type: "string",
+            description:
+              "What must be true for this task to be done. 3-3000 characters. Required by Factory.",
+          },
+          priority: {
+            type: "string",
+            enum: ["low", "normal", "high"],
+            description: "Defaults to normal.",
+          },
+          status: {
+            type: "string",
+            enum: ["backlog", "queued"],
+            description:
+              "Defaults to backlog. 'queued' also creates a worker run and requires a ```run block in acceptance.",
+          },
+        },
+        required: ["projectId", "title", "acceptance"],
+      },
+    },
+    {
+      name: "claim_factory_task",
+      description:
+        "Claim a task by opening a Factory work session. This is what moves the task to 'running' on the board, because Factory has no plain status edit for it. Also starts the local workflow for that task. Use the task id from list_factory_tasks. If the task is held by another device, pass 'takeoverReason' to take it over; Factory records that reason on the board and locks the previous holder out.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          recordId: {
+            type: "string",
+            description: "Factory task id (UUID) to claim.",
+          },
+          step: {
+            type: "string",
+            description: "Short description of what you are about to do, shown on the device row (max 240 chars).",
+          },
+          takeoverReason: {
+            type: "string",
+            description:
+              "Alasan mengambil alih task yang sedang dipegang perangkat lain (3-500 karakter). Wajib diisi hanya bila task itu dipegang perangkat lain. Alasannya dicatat di papan.",
+          },
+        },
+        required: ["recordId"],
+      },
+    },
+    {
+      name: "sync_task_status",
+      description:
+        "Report a task status change to Factory using the endpoint that supports it: review, blocked and paused finish the work session; backlog, queued, cancelled and done move the task. 'done' is the approval step: Factory accepts it only when the task is currently in review, and it marks the work as finished. 'running' is set by claim_factory_task, not here.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          recordId: {
+            type: "string",
+            description: "Factory task id (UUID).",
+          },
+          status: {
+            type: "string",
+            enum: ["backlog", "queued", "review", "blocked", "paused", "cancelled", "done"],
+            description:
+              "New status. 'running' is set by claim_factory_task, not here. 'done' is the approval step and is only valid when the task is currently in review.",
+          },
+          reason: {
+            type: "string",
+            description: "Required when status is 'blocked'; used as the session summary otherwise.",
+          },
+          nextAction: {
+            type: "string",
+            description: "What happens next. Appended to the session summary.",
+          },
+        },
+        required: ["recordId", "status"],
+      },
+    },
   ];
 }

package/tools/handler-modules/commit-handlers.js

@@ -1,4 +1,5 @@
-import { textResponse, isReleaseSatisfied, formatChecklist, handleReadyCheck } from "./shared.js";
+import { textResponse, isReleaseSatisfied, formatChecklist } from "./shared.js";
+import { handleReadyCheck } from "./status-handlers.js";
 import { containsTestFilesInStatus } from "../../git-helpers.js";
 
 export async function handleCommitAndPush(args, context) {

package/tools/handler-modules/factory-handlers.js

@@ -0,0 +1,276 @@
+import { textResponse } from "./shared.js";
+import {
+  readFactoryConfig,
+  listTasks,
+  findTask,
+  claimTask,
+  updateTaskStatus,
+  createTask,
+  listProjects,
+  formatTaskList,
+  formatProjectList,
+  planStatusTransition,
+} from "../../factory-client.js";
+
+/**
+ * Factory tools stay inert unless a Factory URL and credentials are set.
+ * That keeps the MCP server usable on machines without Factory access.
+ */
+function requireConfig() {
+  const config = readFactoryConfig();
+  if (!config) {
+    return {
+      config: null,
+      response: textResponse(
+        [
+          "Factory is not configured on this machine.",
+          "",
+          "Set these environment variables where the MCP server is launched:",
+          "  FACTORY_URL=https://factory.programinglive.com",
+          "  FACTORY_TOKEN=<PocketBase activity_users token>",
+          "",
+          "Or let the client log in for you:",
+          "  FACTORY_EMAIL=<activity_users email>",
+          "  FACTORY_PASSWORD=<password>",
+          "",
+          "Optional:",
+          "  FACTORY_PB_URL=<PocketBase base URL, default https://pocketbase.programinglive.com>",
+          "  FACTORY_MACHINE_ID=<name shown on the device row>",
+          "  FACTORY_DEVICE_ID=<fixed device UUID>",
+        ].join("\n"),
+      ),
+    };
+  }
+  return { config, response: null };
+}
+
+export async function handleListFactoryTasks(args = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const statuses = Array.isArray(args.statuses) && args.statuses.length ? args.statuses : undefined;
+  const project = typeof args.project === "string" && args.project.trim() ? args.project.trim() : null;
+  const limit = Number.isFinite(args.limit) ? Math.min(Math.max(args.limit, 1), 200) : 50;
+
+  try {
+    const tasks = await listTasks(config, { statuses, project, limit });
+    return textResponse(formatTaskList(tasks));
+  } catch (error) {
+    return textResponse(`Could not read the Factory queue: ${error.message}`);
+  }
+}
+
+/**
+ * Formats how long ago a work session was last seen.
+ *
+ * Returns an empty string when the timestamp is missing or unparsable, so the
+ * caller can leave that part of the message out instead of printing garbage.
+ */
+function formatLastSeen(value) {
+  if (!value) return "";
+  const seen = Date.parse(value);
+  if (Number.isNaN(seen)) return "";
+  const minutes = Math.floor((Date.now() - seen) / 60000);
+  if (minutes < 1) return "baru saja";
+  if (minutes < 60) return `${minutes} menit lalu`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} jam lalu`;
+  return `${Math.floor(hours / 24)} hari lalu`;
+}
+
+/**
+ * Builds the message shown when Factory refuses a claim because another device
+ * still holds the task.
+ *
+ * The refusal is actionable: it names the holder and shows the exact call to
+ * make, so the agent does not have to guess which parameter is missing.
+ */
+function takeoverRequiredMessage(title, holder = {}) {
+  const seen = formatLastSeen(holder.lastSeenAt);
+  const holderText = [holder.deviceName, holder.agent].filter(Boolean).join(" (") + (holder.agent ? ")" : "");
+  return [
+    `"${title}" sedang dikerjakan oleh perangkat lain.`,
+    "",
+    holderText ? `Pemegang sesi: ${holderText}${seen ? `, terakhir terlihat ${seen}` : ""}.` : "",
+    "",
+    "Ambil alih dengan menyertakan alasan (3-500 karakter):",
+    `  claim_factory_task { "recordId": "<id>", "step": "<langkah>", "takeoverReason": "<alasanmu>" }`,
+    "",
+    "Alasannya dicatat di papan, jadi orang berikutnya tahu kenapa pekerjaan berpindah tangan.",
+  ]
+    .filter((line) => line !== "")
+    .join("\n");
+}
+
+export async function handleClaimFactoryTask(args = {}, { workflowState } = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const recordId = typeof args.recordId === "string" ? args.recordId.trim() : "";
+  if (!recordId) {
+    return textResponse("Provide the 'recordId' of the task to claim (see list_factory_tasks).");
+  }
+
+  const takeoverReason = typeof args.takeoverReason === "string" ? args.takeoverReason.trim() : "";
+  // Judul diambil di luar try supaya pesan penolakan tetap menyebut task yang
+  // sebenarnya, bukan teks umum.
+  let taskTitle = "Task ini";
+
+  try {
+    const task = await findTask(config, recordId);
+    if (!task) {
+      return textResponse(`No task with id "${recordId}" is visible to this account.`);
+    }
+    taskTitle = task.title;
+
+    const step = typeof args.step === "string" && args.step.trim() ? args.step.trim() : "Working on the task";
+    const session = await claimTask(config, { recordId, step, takeoverReason });
+    if (!session) throw new Error("Factory accepted the claim but returned no work session.");
+
+    if (workflowState) {
+      workflowState.reset();
+      workflowState.state.currentPhase = "coding";
+      workflowState.state.taskDescription = `[${task.taskKey || task.id}] ${task.title}`;
+      workflowState.state.taskType = "other";
+      await workflowState.save();
+    }
+
+    return textResponse(
+      [
+        `Claimed [${task.taskKey || task.id}] ${task.title}`,
+        `Factory status is now running (work session ${session.id}).`,
+        task.projectName ? `Project: ${task.projectName}` : "",
+        "",
+        "Local workflow started for this task.",
+        "Use 'sync_task_status' with review, blocked or paused to close the session, or done to approve the task once it is in review.",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  } catch (error) {
+    // Factory menolak take over tanpa alasan. Balas dengan arahan yang bisa
+    // dijalankan, bukan dengan pesan error mentah.
+    if (error?.body?.takeoverRequired) {
+      return textResponse(takeoverRequiredMessage(taskTitle, error.body.holder));
+    }
+    return textResponse(`Could not claim the task: ${error.message}`);
+  }
+}
+
+export async function handleSyncTaskStatus(args = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const recordId = typeof args.recordId === "string" ? args.recordId.trim() : "";
+  const status = typeof args.status === "string" ? args.status.trim() : "";
+  const reason = typeof args.reason === "string" ? args.reason : null;
+  const nextAction = typeof args.nextAction === "string" ? args.nextAction : null;
+
+  if (!recordId) {
+    return textResponse("Provide the 'recordId' of the task to update.");
+  }
+  if (!status) {
+    return textResponse("Provide 'status'. Factory accepts: backlog, queued, review, blocked, paused, cancelled, done.");
+  }
+  if (status === "blocked" && !reason) {
+    return textResponse("Marking a task blocked requires a 'reason' so the next person knows what is missing.");
+  }
+
+  // Validate locally so the agent gets an actionable message instead of a
+  // transport error from Factory.
+  try {
+    planStatusTransition(status);
+  } catch (error) {
+    return textResponse(error.message);
+  }
+
+  try {
+    const result = await updateTaskStatus(config, { recordId, status, reason, nextAction });
+
+    return textResponse(
+      [
+        `Updated ${recordId} to ${result.status}.`,
+        result.session?.summary ? `Summary: ${result.session.summary}` : "",
+        result.status === "review" ? "Waiting for human approval in Factory." : "",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  } catch (error) {
+    return textResponse(`Could not update the task: ${error.message}`);
+  }
+}
+
+/**
+ * Lists projects, because create_task needs a real projectId (UUID) and the
+ * agent cannot invent one.
+ */
+export async function handleListFactoryProjects() {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  try {
+    const projects = await listProjects(config);
+    return textResponse(formatProjectList(projects));
+  } catch (error) {
+    return textResponse(`Could not read the Factory projects: ${error.message}`);
+  }
+}
+
+/**
+ * Creates a task on the board through the official write path.
+ *
+ * Defaults to `backlog`. Factory starts a worker run for `queued` tasks, so
+ * recording work must not enqueue execution by accident.
+ */
+export async function handleCreateFactoryTask(args = {}) {
+  const { config, response } = requireConfig();
+  if (!config) return response;
+
+  const title = typeof args.title === "string" ? args.title.trim() : "";
+  const acceptance = typeof args.acceptance === "string" ? args.acceptance.trim() : "";
+
+  if (!title) {
+    return textResponse("Provide 'title' for the task (3-140 characters).");
+  }
+  if (!acceptance) {
+    return textResponse(
+      [
+        "Provide 'acceptance': what must be true for this task to count as done.",
+        "Factory requires it, and it is what the next person checks.",
+      ].join("\n"),
+    );
+  }
+  if (!args.projectId) {
+    return textResponse(
+      "Provide 'projectId'. Run 'list_factory_projects' first - Factory needs a real project UUID.",
+    );
+  }
+
+  try {
+    const created = await createTask(config, {
+      projectId: args.projectId,
+      title,
+      description: args.description,
+      acceptance,
+      priority: args.priority,
+      status: args.status,
+    });
+
+    return textResponse(
+      [
+        `Created task ${created.id ? `[${String(created.id).slice(0, 8)}] ` : ""}${title}`,
+        `Status: ${created.status}${created.status === "backlog" ? " (no worker run started)" : ""}`,
+        created.runId ? `Worker run queued: ${created.runId}` : "",
+        "",
+        created.status === "backlog"
+          ? "Recorded in the backlog. Use claim_factory_task when someone starts working on it."
+          : "Move it out of the queue if execution was not intended.",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  } catch (error) {
+    return textResponse(`Could not create the task: ${error.message}`);
+  }
+}