triflux 3.3.0-dev.1 → 3.3.0-dev.5

package/hub/server.mjs

@@ -13,22 +13,8 @@ import { createStore } from './store.mjs';
 import { createRouter } from './router.mjs';
 import { createHitlManager } from './hitl.mjs';
 import { createPipeServer } from './pipe.mjs';
+import { createAssignCallbackServer } from './assign-callbacks.mjs';
 import { createTools } from './tools.mjs';
-import {
-  ensurePipelineTable,
-  createPipeline,
-} from './pipeline/index.mjs';
-import {
-  readPipelineState,
-  initPipelineState,
-  listPipelineStates,
-} from './pipeline/state.mjs';
-import {
-  teamInfo,
-  teamTaskList,
-  teamTaskUpdate,
-  teamSendMessage,
-} from './team/nativeProxy.mjs';
 
 function isInitializeRequest(body) {
   if (body?.method === 'initialize') return true;
@@ -61,6 +47,22 @@ function isAllowedOrigin(origin) {
   return origin && ALLOWED_ORIGIN_RE.test(origin);
 }
 
+function resolveTeamStatusCode(result) {
+  if (result?.ok) return 200;
+  const code = result?.error?.code;
+  if (code === 'TEAM_NOT_FOUND' || code === 'TASK_NOT_FOUND' || code === 'TASKS_DIR_NOT_FOUND') return 404;
+  if (code === 'CLAIM_CONFLICT' || code === 'MTIME_CONFLICT') return 409;
+  if (code === 'INVALID_TEAM_NAME' || code === 'INVALID_TASK_ID' || code === 'INVALID_TEXT' || code === 'INVALID_FROM' || code === 'INVALID_STATUS') return 400;
+  return 500;
+}
+
+function resolvePipelineStatusCode(result) {
+  if (result?.ok) return 200;
+  if (result?.error === 'pipeline_not_found') return 404;
+  if (result?.error === 'hub_db_not_found') return 503;
+  return 400;
+}
+
 /**
  * tfx-hub 시작
  * @param {object} opts
@@ -82,6 +84,7 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
   const store = createStore(dbPath);
   const router = createRouter(store);
   const pipe = createPipeServer({ router, store, sessionId });
+  const assignCallbacks = createAssignCallbackServer({ store, sessionId });
   const hitl = createHitlManager(store, router);
   const tools = createTools(store, router, hitl, pipe);
   const transports = new Map();
@@ -145,6 +148,8 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
         port,
         pipe_path: pipe.path,
         pipe: pipe.getStatus(),
+        assign_callback_pipe_path: assignCallbacks.path,
+        assign_callback_pipe: assignCallbacks.getStatus(),
       }));
     }
 
@@ -245,28 +250,115 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
           return res.end(JSON.stringify(result));
         }
 
+        if (path === '/bridge/assign/async' && req.method === 'POST') {
+          const {
+            supervisor_agent,
+            worker_agent,
+            task,
+            topic = 'assign.job',
+            payload = {},
+            priority = 5,
+            ttl_ms = 600000,
+            timeout_ms = 600000,
+            max_retries = 0,
+            trace_id,
+            correlation_id,
+          } = body;
+
+          if (!supervisor_agent || !worker_agent || !task) {
+            res.writeHead(400);
+            return res.end(JSON.stringify({ ok: false, error: 'supervisor_agent, worker_agent, task 필수' }));
+          }
+
+          const result = await pipe.executeCommand('assign', {
+            supervisor_agent,
+            worker_agent,
+            task,
+            topic,
+            payload,
+            priority,
+            ttl_ms,
+            timeout_ms,
+            max_retries,
+            trace_id,
+            correlation_id,
+          });
+          res.writeHead(result.ok ? 200 : 400);
+          return res.end(JSON.stringify(result));
+        }
+
+        if (path === '/bridge/assign/result' && req.method === 'POST') {
+          const {
+            job_id,
+            worker_agent,
+            status,
+            attempt,
+            result: assignResult,
+            error: assignError,
+            payload = {},
+            metadata = {},
+          } = body;
+
+          if (!job_id || !status) {
+            res.writeHead(400);
+            return res.end(JSON.stringify({ ok: false, error: 'job_id, status 필수' }));
+          }
+
+          const result = await pipe.executeCommand('assign_result', {
+            job_id,
+            worker_agent,
+            status,
+            attempt,
+            result: assignResult,
+            error: assignError,
+            payload,
+            metadata,
+          });
+          res.writeHead(result.ok ? 200 : 409);
+          return res.end(JSON.stringify(result));
+        }
+
+        if (path === '/bridge/assign/status' && req.method === 'POST') {
+          const result = await pipe.executeQuery('assign_status', body);
+          const statusCode = result.ok ? 200 : (result.error?.code === 'ASSIGN_NOT_FOUND' ? 404 : 400);
+          res.writeHead(statusCode);
+          return res.end(JSON.stringify(result));
+        }
+
+        if (path === '/bridge/assign/retry' && req.method === 'POST') {
+          const { job_id, reason, requested_by } = body;
+          if (!job_id) {
+            res.writeHead(400);
+            return res.end(JSON.stringify({ ok: false, error: 'job_id 필수' }));
+          }
+
+          const result = await pipe.executeCommand('assign_retry', {
+            job_id,
+            reason,
+            requested_by,
+          });
+          const statusCode = result.ok ? 200
+            : result.error?.code === 'ASSIGN_NOT_FOUND' ? 404
+              : result.error?.code === 'ASSIGN_RETRY_EXHAUSTED' ? 409
+                : 400;
+          res.writeHead(statusCode);
+          return res.end(JSON.stringify(result));
+        }
+
         if (req.method === 'POST') {
           let teamResult = null;
           if (path === '/bridge/team/info' || path === '/bridge/team-info') {
-            teamResult = await teamInfo(body);
+            teamResult = await pipe.executeQuery('team_info', body);
           } else if (path === '/bridge/team/task-list' || path === '/bridge/team-task-list') {
-            teamResult = await teamTaskList(body);
+            teamResult = await pipe.executeQuery('team_task_list', body);
           } else if (path === '/bridge/team/task-update' || path === '/bridge/team-task-update') {
-            teamResult = await teamTaskUpdate(body);
+            teamResult = await pipe.executeCommand('team_task_update', body);
           } else if (path === '/bridge/team/send-message' || path === '/bridge/team-send-message') {
-            teamResult = await teamSendMessage(body);
+            teamResult = await pipe.executeCommand('team_send_message', body);
           }
 
           if (teamResult) {
-            let status = 200;
-            const code = teamResult?.error?.code;
-            if (!teamResult.ok) {
-              if (code === 'TEAM_NOT_FOUND' || code === 'TASK_NOT_FOUND' || code === 'TASKS_DIR_NOT_FOUND') status = 404;
-              else if (code === 'CLAIM_CONFLICT' || code === 'MTIME_CONFLICT') status = 409;
-              else if (code === 'INVALID_TEAM_NAME' || code === 'INVALID_TASK_ID' || code === 'INVALID_TEXT' || code === 'INVALID_FROM' || code === 'INVALID_STATUS') status = 400;
-              else status = 500;
-            }
-            res.writeHead(status);
+            res.writeHead(resolveTeamStatusCode(teamResult));
             return res.end(JSON.stringify(teamResult));
           }
 
@@ -277,51 +369,42 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
 
           // ── 파이프라인 엔드포인트 ──
           if (path === '/bridge/pipeline/state' && req.method === 'POST') {
-            ensurePipelineTable(store.db);
-            const { team_name } = body;
-            const state = readPipelineState(store.db, team_name);
-            res.writeHead(state ? 200 : 404);
-            return res.end(JSON.stringify(state
-              ? { ok: true, data: state }
-              : { ok: false, error: 'pipeline_not_found' }));
+            const result = await pipe.executeQuery('pipeline_state', body);
+            res.writeHead(resolvePipelineStatusCode(result));
+            return res.end(JSON.stringify(result));
           }
 
           if (path === '/bridge/pipeline/advance' && req.method === 'POST') {
-            ensurePipelineTable(store.db);
-            const { team_name, phase } = body;
-            const pipeline = createPipeline(store.db, team_name);
-            const result = pipeline.advance(phase);
-            res.writeHead(result.ok ? 200 : 400);
+            const result = await pipe.executeCommand('pipeline_advance', body);
+            res.writeHead(resolvePipelineStatusCode(result));
             return res.end(JSON.stringify(result));
           }
 
           if (path === '/bridge/pipeline/init' && req.method === 'POST') {
-            ensurePipelineTable(store.db);
-            const { team_name, fix_max, ralph_max } = body;
-            const state = initPipelineState(store.db, team_name, { fix_max, ralph_max });
-            res.writeHead(200);
-            return res.end(JSON.stringify({ ok: true, data: state }));
+            const result = await pipe.executeCommand('pipeline_init', body);
+            res.writeHead(resolvePipelineStatusCode(result));
+            return res.end(JSON.stringify(result));
           }
 
           if (path === '/bridge/pipeline/list' && req.method === 'POST') {
-            ensurePipelineTable(store.db);
-            const states = listPipelineStates(store.db);
-            res.writeHead(200);
-            return res.end(JSON.stringify({ ok: true, data: states }));
+            const result = await pipe.executeQuery('pipeline_list', body);
+            res.writeHead(resolvePipelineStatusCode(result));
+            return res.end(JSON.stringify(result));
           }
         }
 
         if (path === '/bridge/context' && req.method === 'POST') {
-          const { agent_id, topics, max_messages = 10 } = body;
+          const { agent_id, topics, max_messages = 10, auto_ack = true } = body;
           if (!agent_id) {
             res.writeHead(400);
             return res.end(JSON.stringify({ ok: false, error: 'agent_id 필수' }));
           }
 
-          const result = await pipe.executeQuery('context', {
+          const result = await pipe.executeQuery('drain', {
             agent_id,
             topics,
             max_messages,
+            auto_ack,
           });
           res.writeHead(200);
           return res.end(JSON.stringify(result));
@@ -441,6 +524,7 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
 
   mkdirSync(PID_DIR, { recursive: true });
   await pipe.start();
+  await assignCallbacks.start();
 
   return new Promise((resolve, reject) => {
     httpServer.listen(port, host, () => {
@@ -449,9 +533,12 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
         host,
         dbPath,
         pid: process.pid,
+        hubToken: HUB_TOKEN,
         url: `http://${host}:${port}/mcp`,
         pipe_path: pipe.path,
         pipePath: pipe.path,
+        assign_callback_pipe_path: assignCallbacks.path,
+        assignCallbackPipePath: assignCallbacks.path,
       };
 
       writeFileSync(PID_FILE, JSON.stringify({
@@ -461,10 +548,11 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
         url: info.url,
         pipe_path: pipe.path,
         pipePath: pipe.path,
+        assign_callback_pipe_path: assignCallbacks.path,
         started: Date.now(),
       }));
 
-      console.log(`[tfx-hub] MCP 서버 시작: ${info.url} / pipe ${pipe.path} (PID ${process.pid})`);
+      console.log(`[tfx-hub] MCP 서버 시작: ${info.url} / pipe ${pipe.path} / assign-callback ${assignCallbacks.path} (PID ${process.pid})`);
 
       const stopFn = async () => {
         router.stopSweeper();
@@ -475,13 +563,23 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
         }
         transports.clear();
         await pipe.stop();
+        await assignCallbacks.stop();
         store.close();
         try { unlinkSync(PID_FILE); } catch {}
         try { unlinkSync(TOKEN_FILE); } catch {}
         await new Promise((resolveClose) => httpServer.close(resolveClose));
       };
 
-      resolve({ ...info, httpServer, store, router, hitl, pipe, stop: stopFn });
+      resolve({
+        ...info,
+        httpServer,
+        store,
+        router,
+        hitl,
+        pipe,
+        assignCallbacks,
+        stop: stopFn,
+      });
     });
     httpServer.on('error', reject);
   });

package/hub/store.mjs

@@ -80,6 +80,17 @@ function parseHumanRequestRow(row) {
   };
 }
 
+function parseAssignRow(row) {
+  if (!row) return null;
+  const { payload_json, result_json, error_json, ...rest } = row;
+  return {
+    ...rest,
+    payload: parseJson(payload_json, {}),
+    result: parseJson(result_json, null),
+    error: parseJson(error_json, null),
+  };
+}
+
 /**
  * 저장소 생성
  * @param {string} dbPath
@@ -96,7 +107,7 @@ export function createStore(dbPath) {
 
   const schemaSQL = readFileSync(join(__dirname, 'schema.sql'), 'utf8');
   db.exec("CREATE TABLE IF NOT EXISTS _meta (key TEXT PRIMARY KEY, value TEXT)");
-  const SCHEMA_VERSION = '1';
+  const SCHEMA_VERSION = '2';
   const curVer = (() => {
     try { return db.prepare("SELECT value FROM _meta WHERE key='schema_version'").pluck().get(); }
     catch { return null; }
@@ -162,6 +173,45 @@ export function createStore(dbPath) {
     insertDL: db.prepare('INSERT OR REPLACE INTO dead_letters (message_id, reason, failed_at_ms, last_error) VALUES (?,?,?,?)'),
     getDL: db.prepare('SELECT * FROM dead_letters ORDER BY failed_at_ms DESC LIMIT ?'),
 
+    insertAssign: db.prepare(`
+      INSERT INTO assign_jobs (
+        job_id, supervisor_agent, worker_agent, topic, task, payload_json,
+        status, attempt, retry_count, max_retries, priority, ttl_ms, timeout_ms, deadline_ms,
+        trace_id, correlation_id, last_message_id, result_json, error_json,
+        created_at_ms, updated_at_ms, started_at_ms, completed_at_ms, last_retry_at_ms
+      ) VALUES (
+        @job_id, @supervisor_agent, @worker_agent, @topic, @task, @payload_json,
+        @status, @attempt, @retry_count, @max_retries, @priority, @ttl_ms, @timeout_ms, @deadline_ms,
+        @trace_id, @correlation_id, @last_message_id, @result_json, @error_json,
+        @created_at_ms, @updated_at_ms, @started_at_ms, @completed_at_ms, @last_retry_at_ms
+      )`),
+    getAssign: db.prepare('SELECT * FROM assign_jobs WHERE job_id = ?'),
+    updateAssign: db.prepare(`
+      UPDATE assign_jobs SET
+        supervisor_agent=@supervisor_agent,
+        worker_agent=@worker_agent,
+        topic=@topic,
+        task=@task,
+        payload_json=@payload_json,
+        status=@status,
+        attempt=@attempt,
+        retry_count=@retry_count,
+        max_retries=@max_retries,
+        priority=@priority,
+        ttl_ms=@ttl_ms,
+        timeout_ms=@timeout_ms,
+        deadline_ms=@deadline_ms,
+        trace_id=@trace_id,
+        correlation_id=@correlation_id,
+        last_message_id=@last_message_id,
+        result_json=@result_json,
+        error_json=@error_json,
+        updated_at_ms=@updated_at_ms,
+        started_at_ms=@started_at_ms,
+        completed_at_ms=@completed_at_ms,
+        last_retry_at_ms=@last_retry_at_ms
+      WHERE job_id=@job_id`),
+
     findExpired: db.prepare("SELECT id FROM messages WHERE status='queued' AND expires_at_ms < ?"),
     urgentDepth: db.prepare("SELECT COUNT(*) as cnt FROM messages WHERE status='queued' AND priority >= 7"),
     normalDepth: db.prepare("SELECT COUNT(*) as cnt FROM messages WHERE status='queued' AND priority < 7"),
@@ -169,14 +219,46 @@ export function createStore(dbPath) {
     msgCount: db.prepare('SELECT COUNT(*) as cnt FROM messages'),
     dlqDepth: db.prepare('SELECT COUNT(*) as cnt FROM dead_letters'),
     ackedRecent: db.prepare("SELECT COUNT(*) as cnt FROM messages WHERE status='acked' AND created_at_ms > ? - 300000"),
+    assignCountByStatus: db.prepare('SELECT COUNT(*) as cnt FROM assign_jobs WHERE status = ?'),
+    activeAssignCount: db.prepare("SELECT COUNT(*) as cnt FROM assign_jobs WHERE status IN ('queued','running')"),
   };
 
+  const assignStatusListeners = new Set();
+
+  function buildAssignCallbackEvent(row) {
+    return {
+      job_id: row.job_id,
+      status: row.status,
+      result: row.result ?? row.error ?? null,
+      timestamp: new Date(row.updated_at_ms || Date.now()).toISOString(),
+    };
+  }
+
+  function notifyAssignStatusListeners(row) {
+    const event = buildAssignCallbackEvent(row);
+    for (const listener of Array.from(assignStatusListeners)) {
+      try { listener(event, row); } catch {}
+    }
+  }
+
   function clampMaxMessages(value, fallback = 20) {
     const num = Number(value);
     if (!Number.isFinite(num)) return fallback;
     return Math.max(1, Math.min(Math.trunc(num), 100));
   }
 
+  function clampPriority(value, fallback = 5) {
+    const num = Number(value);
+    if (!Number.isFinite(num)) return fallback;
+    return Math.max(1, Math.min(Math.trunc(num), 9));
+  }
+
+  function clampDuration(value, fallback = 600000, min = 1000, max = 86400000) {
+    const num = Number(value);
+    if (!Number.isFinite(num)) return fallback;
+    return Math.max(min, Math.min(Math.trunc(num), max));
+  }
+
   const store = {
     db,
     uuidv7,
@@ -365,6 +447,201 @@ export function createStore(dbPath) {
       return S.getDL.all(limit);
     },
 
+    createAssign({
+      job_id,
+      supervisor_agent,
+      worker_agent,
+      topic = 'assign.job',
+      task = '',
+      payload = {},
+      status = 'queued',
+      attempt = 1,
+      retry_count = 0,
+      max_retries = 0,
+      priority = 5,
+      ttl_ms = 600000,
+      timeout_ms = 600000,
+      deadline_ms,
+      trace_id,
+      correlation_id,
+      last_message_id = null,
+      result = null,
+      error = null,
+    }) {
+      const now = Date.now();
+      const normalizedTimeout = clampDuration(timeout_ms, 600000);
+      const row = {
+        job_id: job_id || uuidv7(),
+        supervisor_agent,
+        worker_agent,
+        topic: String(topic || 'assign.job'),
+        task: String(task || ''),
+        payload_json: JSON.stringify(payload || {}),
+        status,
+        attempt: Math.max(1, Number(attempt) || 1),
+        retry_count: Math.max(0, Number(retry_count) || 0),
+        max_retries: Math.max(0, Number(max_retries) || 0),
+        priority: clampPriority(priority, 5),
+        ttl_ms: clampDuration(ttl_ms, normalizedTimeout),
+        timeout_ms: normalizedTimeout,
+        deadline_ms: Number.isFinite(Number(deadline_ms))
+          ? Math.trunc(Number(deadline_ms))
+          : now + normalizedTimeout,
+        trace_id: trace_id || uuidv7(),
+        correlation_id: correlation_id || uuidv7(),
+        last_message_id,
+        result_json: result == null ? null : JSON.stringify(result),
+        error_json: error == null ? null : JSON.stringify(error),
+        created_at_ms: now,
+        updated_at_ms: now,
+        started_at_ms: status === 'running' ? now : null,
+        completed_at_ms: ['succeeded', 'failed', 'timed_out'].includes(status) ? now : null,
+        last_retry_at_ms: retry_count > 0 ? now : null,
+      };
+      S.insertAssign.run(row);
+      const inserted = store.getAssign(row.job_id);
+      notifyAssignStatusListeners(inserted);
+      return inserted;
+    },
+
+    getAssign(jobId) {
+      return parseAssignRow(S.getAssign.get(jobId));
+    },
+
+    updateAssignStatus(jobId, status, patch = {}) {
+      const current = store.getAssign(jobId);
+      if (!current) return null;
+
+      const now = Date.now();
+      const nextStatus = status || current.status;
+      const isTerminal = ['succeeded', 'failed', 'timed_out'].includes(nextStatus);
+      const nextTimeout = clampDuration(patch.timeout_ms ?? current.timeout_ms, current.timeout_ms);
+      const nextRow = {
+        job_id: current.job_id,
+        supervisor_agent: patch.supervisor_agent ?? current.supervisor_agent,
+        worker_agent: patch.worker_agent ?? current.worker_agent,
+        topic: patch.topic ?? current.topic,
+        task: patch.task ?? current.task,
+        payload_json: JSON.stringify(patch.payload ?? current.payload ?? {}),
+        status: nextStatus,
+        attempt: Math.max(1, Number(patch.attempt ?? current.attempt) || current.attempt || 1),
+        retry_count: Math.max(0, Number(patch.retry_count ?? current.retry_count) || 0),
+        max_retries: Math.max(0, Number(patch.max_retries ?? current.max_retries) || 0),
+        priority: clampPriority(patch.priority ?? current.priority, current.priority || 5),
+        ttl_ms: clampDuration(patch.ttl_ms ?? current.ttl_ms, current.ttl_ms || nextTimeout),
+        timeout_ms: nextTimeout,
+        deadline_ms: (() => {
+          if (Object.prototype.hasOwnProperty.call(patch, 'deadline_ms')) {
+            return patch.deadline_ms == null ? null : Math.trunc(Number(patch.deadline_ms));
+          }
+          if (isTerminal) return null;
+          if (nextStatus === 'running' && !current.deadline_ms) return now + nextTimeout;
+          return current.deadline_ms;
+        })(),
+        trace_id: patch.trace_id ?? current.trace_id,
+        correlation_id: patch.correlation_id ?? current.correlation_id,
+        last_message_id: Object.prototype.hasOwnProperty.call(patch, 'last_message_id')
+          ? patch.last_message_id
+          : current.last_message_id,
+        result_json: Object.prototype.hasOwnProperty.call(patch, 'result')
+          ? (patch.result == null ? null : JSON.stringify(patch.result))
+          : (current.result == null ? null : JSON.stringify(current.result)),
+        error_json: Object.prototype.hasOwnProperty.call(patch, 'error')
+          ? (patch.error == null ? null : JSON.stringify(patch.error))
+          : (current.error == null ? null : JSON.stringify(current.error)),
+        updated_at_ms: now,
+        started_at_ms: Object.prototype.hasOwnProperty.call(patch, 'started_at_ms')
+          ? patch.started_at_ms
+          : (nextStatus === 'running' ? (current.started_at_ms || now) : current.started_at_ms),
+        completed_at_ms: Object.prototype.hasOwnProperty.call(patch, 'completed_at_ms')
+          ? patch.completed_at_ms
+          : (isTerminal ? (current.completed_at_ms || now) : current.completed_at_ms),
+        last_retry_at_ms: Object.prototype.hasOwnProperty.call(patch, 'last_retry_at_ms')
+          ? patch.last_retry_at_ms
+          : current.last_retry_at_ms,
+      };
+      S.updateAssign.run(nextRow);
+      const updated = store.getAssign(jobId);
+      if (updated && current.status !== updated.status) {
+        notifyAssignStatusListeners(updated);
+      }
+      return updated;
+    },
+
+    listAssigns({
+      supervisor_agent,
+      worker_agent,
+      status,
+      statuses,
+      trace_id,
+      correlation_id,
+      active_before_ms,
+      limit = 50,
+    } = {}) {
+      const clauses = [];
+      const values = [];
+
+      if (supervisor_agent) {
+        clauses.push('supervisor_agent = ?');
+        values.push(supervisor_agent);
+      }
+      if (worker_agent) {
+        clauses.push('worker_agent = ?');
+        values.push(worker_agent);
+      }
+      if (trace_id) {
+        clauses.push('trace_id = ?');
+        values.push(trace_id);
+      }
+      if (correlation_id) {
+        clauses.push('correlation_id = ?');
+        values.push(correlation_id);
+      }
+
+      const statusList = Array.isArray(statuses) && statuses.length
+        ? statuses
+        : (status ? [status] : []);
+      if (statusList.length) {
+        clauses.push(`status IN (${statusList.map(() => '?').join(',')})`);
+        values.push(...statusList);
+      }
+
+      if (Number.isFinite(Number(active_before_ms))) {
+        clauses.push('deadline_ms IS NOT NULL AND deadline_ms <= ?');
+        values.push(Math.trunc(Number(active_before_ms)));
+      }
+
+      const sql = `
+        SELECT * FROM assign_jobs
+        ${clauses.length ? `WHERE ${clauses.join(' AND ')}` : ''}
+        ORDER BY updated_at_ms DESC
+        LIMIT ?`;
+      values.push(clampMaxMessages(limit, 50));
+      return db.prepare(sql).all(...values).map(parseAssignRow);
+    },
+
+    retryAssign(jobId, patch = {}) {
+      const current = store.getAssign(jobId);
+      if (!current) return null;
+
+      const nextRetryCount = Math.max(0, Number(patch.retry_count ?? current.retry_count + 1) || 0);
+      const nextAttempt = Math.max(current.attempt + 1, Number(patch.attempt ?? current.attempt + 1) || 1);
+      const nextTimeout = clampDuration(patch.timeout_ms ?? current.timeout_ms, current.timeout_ms);
+      return store.updateAssignStatus(jobId, 'queued', {
+        retry_count: nextRetryCount,
+        attempt: nextAttempt,
+        timeout_ms: nextTimeout,
+        ttl_ms: patch.ttl_ms ?? current.ttl_ms,
+        deadline_ms: Date.now() + nextTimeout,
+        completed_at_ms: null,
+        started_at_ms: null,
+        last_retry_at_ms: Date.now(),
+        result: patch.result ?? null,
+        error: Object.prototype.hasOwnProperty.call(patch, 'error') ? patch.error : current.error,
+        last_message_id: null,
+      });
+    },
+
     sweepExpired() {
       const now = Date.now();
       return db.transaction(() => {
@@ -386,6 +663,16 @@ export function createStore(dbPath) {
       };
     },
 
+    onAssignStatusChange(listener) {
+      if (typeof listener !== 'function') {
+        return () => {};
+      }
+      assignStatusListeners.add(listener);
+      return () => {
+        assignStatusListeners.delete(listener);
+      };
+    },
+
     getDeliveryStats() {
       return {
         total_deliveries: S.ackedRecent.get(Date.now()).cnt,
@@ -397,6 +684,7 @@ export function createStore(dbPath) {
       return {
         online_agents: S.onlineCount.get().cnt,
         total_messages: S.msgCount.get().cnt,
+        active_assign_jobs: S.activeAssignCount.get().cnt,
         ...store.getQueueDepths(),
       };
     },
@@ -406,6 +694,10 @@ export function createStore(dbPath) {
         online_agents: S.onlineCount.get().cnt,
         total_messages: S.msgCount.get().cnt,
         dlq: S.dlqDepth.get().cnt,
+        assign_queued: S.assignCountByStatus.get('queued').cnt,
+        assign_running: S.assignCountByStatus.get('running').cnt,
+        assign_failed: S.assignCountByStatus.get('failed').cnt,
+        assign_timed_out: S.assignCountByStatus.get('timed_out').cnt,
       };
     },
   };