dsh-sansheng-liubu/workbench/host/service.mjs

1584 lines
70 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 工作台业务服务:纯业务,不碰 HTTP、不碰宿主会话 API。
//
// 三类职责:
// 1. 入口校验(项目隔离):凡是以实体 ID 为参数的调用,先确认项目存在,
// 再确认目标记录属于该项目。伪造 ID 与跨项目引用各自返回确定的错误码,
// 且不泄露“别的项目里有没有这条记录”。
// 2. 契约操作:registerProject / listSeats / bindDepartmentSession / saveDepartmentConfig /
// createTask / dispatchTask / reportTaskResult / requestTaskInput / syncDecision。
// 3. 投影:bootstrap 一次拿全(项目列表 + 十席 + 任务 + 成果),UI 只读投影。
//
// 幂等与状态机全部下沉到 core:store.recordDispatch / store.recordResult 自带去重,
// tasks.decide 负责完成判定。这里只做三件事:组织一次事务、把 core 异常翻成带 code 的业务错误、
// 保证任何返回值都是副本(调用方改返回值改不到账本)。
import { isIdOf } from '../core/ids.mjs'
import { ROLES, isRoleId, layoutGroups } from '../core/roles.mjs'
import { isTerminal } from '../core/states.mjs'
import {
applyDecision,
beginAttempt,
cancelTask as cancelTaskDecision,
createTask as createTaskRecord,
decide,
isOpenTask,
startTask,
} from '../core/tasks.mjs'
import { StoreError } from '../core/store.mjs'
export const WORKBENCH_SERVICE_VERSION = 1
/** 错误码:路由层据此映射 HTTP 状态码,调用方据此分支,永远不解析 message。 */
export const SERVICE_CODES = Object.freeze({
INVALID_INPUT: 'INVALID_INPUT',
INVALID_ROLE: 'INVALID_ROLE',
NOT_FOUND: 'NOT_FOUND',
CROSS_PROJECT: 'CROSS_PROJECT',
CONFIG_CONFLICT: 'CONFIG_CONFLICT',
SESSION_CONFLICT: 'SESSION_CONFLICT',
DUPLICATE_PROJECT: 'DUPLICATE_PROJECT',
INVALID_STATE: 'INVALID_STATE',
DISPATCH_INVALID: 'DISPATCH_INVALID',
ATTEMPT_MISMATCH: 'ATTEMPT_MISMATCH',
REPORT_INVALID: 'REPORT_INVALID',
INTERNAL: 'INTERNAL',
})
export class ServiceError extends Error {
constructor(code, message, details = undefined) {
super(message)
this.name = 'ServiceError'
this.code = code
if (details !== undefined) this.details = details
}
}
// ---------- 纯工具 ----------
function requireText(value, field) {
if (typeof value !== 'string' || value.trim() === '') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `${field} 必须是非空字符串`, { field })
}
return value
}
function optionalText(value, field) {
if (value === undefined || value === null) return null
if (typeof value !== 'string') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `${field} 必须是字符串或 null`, { field })
}
return value
}
function requireRole(value, field) {
if (!isRoleId(value)) {
throw new ServiceError(SERVICE_CODES.INVALID_ROLE, `${field} 不是已知部门: ${String(value)}`, { field })
}
return value
}
function requireBool(value, field) {
if (value === undefined) return false
if (typeof value !== 'boolean') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `${field} 必须是布尔值`, { field })
}
return value
}
function optionalArray(value, field) {
if (value === undefined || value === null) return []
if (!Array.isArray(value)) throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `${field} 必须是数组`, { field })
return value.map((item) => (typeof item === 'string' ? item : JSON.parse(JSON.stringify(item))))
}
/** 深拷贝:对外只给副本,避免调用方拿到账本里的同一个对象。 */
function copy(value) {
return value === undefined || value === null ? value : JSON.parse(JSON.stringify(value))
}
/** store 的 Getter 名 → 实体名(ID 前缀)与集合名(归属校验用)。 */
const GETTERS = Object.freeze({
project: { get: 'getProject', entity: 'project', prefix: 'project' },
task: { get: 'getTask', entity: 'task', prefix: 'task' },
attempt: { get: 'getAttempt', entity: 'attempt', prefix: 'attempt' },
dispatch: { get: 'getDispatch', entity: 'dispatch', prefix: 'dispatch' },
result: { get: 'getResult', entity: 'result', prefix: 'result' },
artifact: { get: 'getArtifact', entity: 'artifact', prefix: 'artifact' },
})
/**
* 宿主运行终态:只认 成功 / 失败 / 取消 / 仍在跑。
* 未知字符串一律拒绝——把 "done" 当成功正是方案 §7.3 明令禁止的猜测。
*/
const RUN_TERMINALS = Object.freeze(['succeeded', 'failed', 'cancelled', 'running'])
function normalizeRunTerminal(value, field = 'runTerminal') {
if (value === undefined || value === null) return null
if (typeof value !== 'string' || !RUN_TERMINALS.includes(value)) {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `${field} 取值非法: ${String(value)}`, { allowed: RUN_TERMINALS })
}
return value
}
/** 宿主终态 → attempt 状态。attempt 跟着落,但业务结论只由 tasks.decide 给。 */
const ATTEMPT_STATE_OF_RUN = Object.freeze({ succeeded: 'succeeded', failed: 'failed', cancelled: 'cancelled' })
export function createWorkbenchService(options = {}) {
const { store, clock = Date.now, env = process.env, fileExists = null, memory = null } = options
if (store === undefined || store === null || typeof store.mutate !== 'function') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'createWorkbenchService 需要 WorkbenchStore')
}
const nowIso = () => new Date(clock()).toISOString()
// ---------- 异常翻译 ----------
/**
* core 的异常统一翻成 ServiceError,保留 code 与 details。
* CROSS_PROJECT 的 message 改写成不含其他项目 ID 的版本,避免把归属泄露出去。
*/
function translate(error) {
if (error instanceof ServiceError) return error
if (error instanceof StoreError) {
const details = error.details
switch (error.code) {
case 'CROSS_PROJECT':
return new ServiceError(SERVICE_CODES.CROSS_PROJECT, '引用的记录不属于本项目', details)
case 'NOT_FOUND':
return new ServiceError(SERVICE_CODES.NOT_FOUND, error.message, details)
case 'CAS_CONFLICT':
return new ServiceError(SERVICE_CODES.CONFIG_CONFLICT, error.message, details)
case 'SESSION_CONFLICT':
return new ServiceError(SERVICE_CODES.SESSION_CONFLICT, error.message, details)
case 'DUPLICATE_PROJECT':
return new ServiceError(SERVICE_CODES.DUPLICATE_PROJECT, error.message, details)
case 'INVALID_ROLE':
return new ServiceError(SERVICE_CODES.INVALID_ROLE, error.message, details)
case 'INVALID_INPUT':
return new ServiceError(SERVICE_CODES.INVALID_INPUT, error.message, details)
case 'DUPLICATE_ID':
// ID 由随机源生成却撞了已有记录:属于宿主侧内部故障,不是调用方的错,
// 更不能伪装成"当前状态不接受该操作"。
return new ServiceError(SERVICE_CODES.INTERNAL, `生成的主键重复(${error.message}),请检查随机源`, { ...details, storeCode: error.code })
default:
// INVALID_STATE / INVALID_ID / CORRUPT 等:状态机与形状问题,
// 对调用方而言都是“当前数据不接受这个操作”,归到 INVALID_STATE,code 保留在 details。
return new ServiceError(SERVICE_CODES.INVALID_STATE, error.message, { ...details, storeCode: error.code })
}
}
// tasks.mjs 的 TaskError:code 语义已经够用,原样带出(INVALID_STATE / ACTIVE_ATTEMPT / CROSS_TASK 等)。
if (error !== null && typeof error === 'object' && typeof error.code === 'string' && typeof error.message === 'string') {
return new ServiceError(error.code, error.message, error.details)
}
const wrapped = new ServiceError(SERVICE_CODES.INTERNAL, error instanceof Error ? error.message : String(error))
wrapped.cause = error
return wrapped
}
/** 包一层:把同步异常翻译成 ServiceError,调用点就不必逐处 try/catch。 */
function guard(fn) {
return (...args) => {
try {
return fn(...args)
} catch (error) {
throw translate(error)
}
}
}
// ---------- 项目隔离 ----------
/**
* 项目必须存在。不存在与伪造同一个返回:凡不可见的项目都是 NOT_FOUND,
* 调用方无法用它区分“没有这个项目”和“这个项目不属于你”。
*/
function projectIdOf(input) {
const projectId = input === null || typeof input !== 'object' ? input : input.projectId
if (typeof projectId !== 'string' || !isIdOf('project', projectId)) {
throw new ServiceError(SERVICE_CODES.NOT_FOUND, '项目不存在', { field: 'projectId' })
}
const project = store.getProject(projectId)
if (project === undefined) throw new ServiceError(SERVICE_CODES.NOT_FOUND, '项目不存在', { field: 'projectId' })
return project
}
/**
* 归属校验的公共实现:先验项目,再验 ID 形状,最后验归属。
* - ID 形状非法或查不到 → NOT_FOUND(伪造/已删不可区分)
* - 查到了但 projectId 不符 → CROSS_PROJECT
* 返回值里不带任何其他项目的字段。
*/
function ownedRow(project, kind, id, field) {
const spec = GETTERS[kind]
if (typeof id !== 'string' || !isIdOf(spec.prefix, id)) {
throw new ServiceError(SERVICE_CODES.NOT_FOUND, `${field} 不存在`, { field })
}
const row = store[spec.get](id)
if (row === undefined || row === null) throw new ServiceError(SERVICE_CODES.NOT_FOUND, `${field} 不存在`, { field })
if (row.projectId !== project.id) {
throw new ServiceError(SERVICE_CODES.CROSS_PROJECT, `${field} 不属于本项目`, { field })
}
return row
}
const requireTask = (project, id) => ownedRow(project, 'task', id, 'taskId')
const requireAttempt = (project, id) => ownedRow(project, 'attempt', id, 'attemptId')
function requireSeat(project, roleId) {
requireRole(roleId, 'roleId')
const binding = store.getBinding(project.id, roleId)
const config = store.getConfig(project.id, roleId)
if (binding === undefined || config === undefined) {
throw new ServiceError(SERVICE_CODES.NOT_FOUND, `项目中缺少 ${roleId} 的席位记录,账本可能未初始化`, { roleId })
}
// 引用校验要用 bindings.id 这个真实键;角色名不是键。
// 注意 core 的 store.state.bindings 以 `${projectId}\u0000${roleId}` 为键,
// 所以派发时直接内联绑定对象,不再把 binding.id 透传给 _checkReferences。
return { binding, config }
}
// ---------- 项目 ----------
/**
* 路径归一:Windows 大小写不敏感、反斜杠与正斜杠等价、末尾分隔符不算差异。
* 约定用不了真实 canonicalize(junction / 短路径要碰文件系统),所以只做到“字符串级等价”,
* 命中时明确说这是识别到的冲突,而不是宣称已经做了完全隔离。
*/
function normalizeRoot(path) {
if (typeof path !== 'string' || path.trim() === '') return null
return path.trim().replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase()
}
/**
* A20:同一目录(含父子目录、junction 指向同一目标)不能登记成两个互不相干的项目。
* 只识别、不篡改:命中就报明确的 relation,调用方要么换目录,要么显式 allowSharedRoot。
*/
function rootConflict(self, canonicalRoot) {
const mine = normalizeRoot(canonicalRoot)
if (mine === null) return null
for (const other of store.listProjects()) {
if (other.id === self?.id) continue
const theirs = normalizeRoot(other.canonicalRoot)
if (theirs === null) continue
if (mine === theirs) {
return { relation: 'same', otherProjectId: other.id, otherHostWorkspaceId: other.hostWorkspaceId, otherRoot: other.canonicalRoot }
}
if (mine.startsWith(`${theirs}/`) || theirs.startsWith(`${mine}/`)) {
return { relation: 'nested', otherProjectId: other.id, otherHostWorkspaceId: other.hostWorkspaceId, otherRoot: other.canonicalRoot }
}
}
return null
}
/**
* 登记项目。同一 hostWorkspaceId 只会得到一个 projectId:
* UI 重复进入同一工作区不该产生两个项目,也不该把已有任务晾在新项目里。
*/
const registerProject = guard((input = {}) => {
const hostWorkspaceId = requireText(input.hostWorkspaceId, 'hostWorkspaceId')
const displayNameCache = input.displayNameCache === undefined ? '' : String(input.displayNameCache ?? '')
const canonicalRoot = optionalText(input.canonicalRoot, 'canonicalRoot')
const existing = store.listProjects().find((row) => row.hostWorkspaceId === hostWorkspaceId)
// 目录冲突先查:两个工作区挂在同一目录(或父子目录)时,任务与会话会互相串,
// 这不是“用户想要两个项目”,而是登记错误,必须在写账之前拦住。
const conflict = rootConflict(existing, canonicalRoot)
if (conflict !== null && input.allowSharedRoot !== true) {
throw new ServiceError(
SERVICE_CODES.DUPLICATE_PROJECT,
conflict.relation === 'same'
? '这个目录已经登记为另一个项目了;同一个目录不会自动隔离'
: '这个目录与已登记的项目是父子关系,两者不会自动隔离',
{ ...conflict, hint: 'allowSharedRoot' },
)
}
if (existing !== undefined) {
const patch = {}
if (existing.displayNameCache !== displayNameCache) patch.displayNameCache = displayNameCache
if (existing.canonicalRoot !== canonicalRoot) patch.canonicalRoot = canonicalRoot
const project = Object.keys(patch).length > 0 ? store.updateProject(existing.id, patch) : existing
return { project: copy(project), duplicate: true, sharedRoot: conflict }
}
try {
const projectId = store.createProject({ hostWorkspaceId, displayNameCache, canonicalRoot })
return { project: copy(store.getProject(projectId)), duplicate: false, sharedRoot: conflict }
} catch (error) {
// 两个窗口同时登记:唯一性在 store 内检查,竞态也归成 duplicate。
if (error instanceof StoreError && error.code === 'DUPLICATE_PROJECT') {
const again = store.listProjects().find((row) => row.hostWorkspaceId === hostWorkspaceId)
if (again !== undefined) return { project: copy(again), duplicate: true, sharedRoot: conflict }
}
throw error
}
})
/** 项目列表:只给投影需要的计数,不把其他项目的实体带出来。 */
function listProjects() {
return store.listProjects().map((project) => {
const tasks = store.listTasks(project.id)
return {
...copy(project),
seatCount: ROLES.length,
taskCount: tasks.length,
openTaskCount: tasks.filter((task) => isOpenTask(task)).length,
}
})
}
function getProject(projectId) {
return copy(projectIdOf({ projectId }))
}
// ---------- 十席 ----------
/**
* 十席布局 + 每席现状。
* connected=false 即“尚未接通”:没有会话或绑定失效时,UI 不能显示可派工。
*/
function seatView(project, seat) {
const binding = store.getBinding(project.id, seat.id)
const config = store.getConfig(project.id, seat.id)
const sessionId = binding?.currentSessionId ?? null
const status = binding?.status ?? 'uninitialized'
const connected = sessionId !== null && status !== 'unavailable'
const activeTask = store
.listTasks(project.id)
.filter((task) => task.ownerRoleId === seat.id && isOpenTask(task))
.sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)))[0]
return {
roleId: seat.id,
name: seat.name,
short: seat.short,
tier: seat.tier,
group: seat.group,
column: seat.column,
row: seat.row,
duty: seat.duty,
canDispatch: seat.canDispatch === true,
connected,
pending: !connected,
pendingLabel: connected ? null : (status === 'unavailable' ? '绑定失效,需重新接通' : '尚未接通'),
activeTaskId: activeTask?.id ?? null,
binding: {
id: binding?.id ?? null,
currentSessionId: sessionId,
// 生成序号是派发时的护栏:换绑后旧序号失效,旧消息不会被送进新会话。
bindingGeneration: binding?.bindingGeneration ?? 0,
status,
historyCount: binding?.historySessionRefs?.length ?? 0,
revision: binding?.revision ?? 0,
},
// 只给 provider/model/effort 名字与修订号,不给任何凭据。
config: {
provider: config?.providerId ?? null,
model: config?.modelId ?? null,
reasoningEffort: config?.reasoningEffort ?? null,
configRevision: config?.configRevision ?? 0,
configured: Boolean(config?.providerId && config?.modelId),
},
}
}
/** 配置的对外视图:provider/model 与账本的 providerId/modelId 只在这一处转换。 */
function configView(config) {
if (config === undefined || config === null) return null
return {
roleId: config.roleId ?? null,
provider: config.providerId ?? null,
model: config.modelId ?? null,
reasoningEffort: config.reasoningEffort ?? null,
configRevision: config.configRevision ?? 0,
updatedAt: config.updatedAt ?? null,
}
}
function listSeats(projectId) {
const project = projectIdOf({ projectId })
return ROLES.map((seat) => seatView(project, seat))
}
function layout() {
return layoutGroups()
}
// ---------- 绑定 ----------
/**
* 绑定部门会话。唯一性与“已绑定时是否允许替换”都在 store 里判定,
* 这里只把 SESSION_CONFLICT / CROSS_PROJECT 原样带出(含 code 与 details.heldBy),
* 让 UI 能说清“这个会话正在被谁持有”,而不是笼统的 500。
*/
const bindDepartmentSession = guard((input = {}) => {
const project = projectIdOf(input)
const roleId = requireRole(input.roleId, 'roleId')
const sessionId = requireText(input.sessionId, 'sessionId')
const allowReplace = requireBool(input.allowReplace, 'allowReplace')
const creationRequestId = optionalText(input.creationRequestId, 'creationRequestId')
try {
const binding = store.bindSession(project.id, roleId, sessionId, { allowReplace, creationRequestId })
return { binding: copy(binding), seat: seatView(project, ROLES.find((seat) => seat.id === roleId)) }
} catch (error) {
if (error instanceof StoreError && error.code === 'SESSION_CONFLICT') {
// 失败分支不带 seat:绑定没变,别让前端误以为状态已更新。
throw translate(error)
}
throw translate(error)
}
})
/** 解除绑定:旧会话进历史,不删除记录。释放后同一 sessionId 才能绑到别处。 */
const releaseDepartmentSession = guard((input = {}) => {
const project = projectIdOf(input)
const roleId = requireRole(input.roleId, 'roleId')
requireSeat(project, roleId)
return { binding: copy(store.releaseBinding(project.id, roleId)) }
})
/** 部门运行态(uninitialized/idle/queued/running/unavailable),由适配器回执驱动。 */
const setDepartmentStatus = guard((input = {}) => {
const project = projectIdOf(input)
const roleId = requireRole(input.roleId, 'roleId')
requireSeat(project, roleId)
const status = requireText(input.status, 'status')
return { binding: copy(store.setBindingStatus(project.id, roleId, status)) }
})
// ---------- 配置(CAS) ----------
/**
* 保存部门模型设置。CAS 冲突必须把“当前值”一起返回,
* 否则 UI 只能提示“保存失败”,用户无从判断是自己过时还是别人改的。
*/
const saveDepartmentConfig = guard((input = {}) => {
const project = projectIdOf(input)
const roleId = requireRole(input.roleId, 'roleId')
requireSeat(project, roleId)
if (!Number.isInteger(input.expectedRevision)) {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'expectedRevision 必须是整数', { field: 'expectedRevision' })
}
if (input.reasoningEffort !== undefined && input.reasoningEffort !== null
&& typeof input.reasoningEffort !== 'string') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'reasoningEffort 必须是字符串或 null', { field: 'reasoningEffort' })
}
try {
const config = store.saveConfig(project.id, roleId, {
provider: input.provider,
model: input.model,
reasoningEffort: input.reasoningEffort ?? null,
}, input.expectedRevision)
// 出参用对外口径(provider/model),不把账本里的 providerId/modelId 漏给 UI:
// 两套命名混用迟早在某处接错。
return { config: configView(config), configRevision: config.configRevision }
} catch (error) {
if (error instanceof StoreError && error.code === 'CAS_CONFLICT') {
const details = error.details ?? {}
throw new ServiceError(SERVICE_CODES.CONFIG_CONFLICT, '配置已被其他窗口修改,请读回后再保存', {
roleId,
expectedRevision: details.expectedRevision ?? input.expectedRevision,
currentRevision: details.currentRevision ?? null,
current: details.current ?? null,
})
}
throw error
}
})
/**
* 先做不花 ID 的前置校验(角色、状态取值、部门是否接通),
* 再进主流程取 ID。失败时一个 ID 都不该被消耗:ID 是业务主键,
* 让失败请求"吃掉"ID 会让重试与断言都对不上。
*/
function preflightCreateTask(input) {
if (input === null || typeof input !== 'object') return input
const sourceRoleId = input.sourceRoleId === undefined ? 'lead' : requireRole(input.sourceRoleId, 'sourceRoleId')
const ownerRoleId = requireRole(input.ownerRoleId, 'ownerRoleId')
const wanted = input.status === undefined ? 'queued' : input.status
if (wanted !== 'queued' && wanted !== 'draft') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `新建任务只能是 queued 或 draft,收到 ${String(wanted)}`, { field: 'status' })
}
if (wanted === 'queued' && typeof input.projectId === 'string' && isIdOf('project', input.projectId)) {
const binding = store.getBinding(input.projectId, ownerRoleId)
if (binding?.currentSessionId === null || binding?.currentSessionId === undefined) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, `${ownerRoleId} 尚未接通会话,不能直接入队;可先存草稿`, {
roleId: ownerRoleId,
hint: 'draft',
})
}
}
return input
}
// ---------- 任务 ----------
/**
* 建任务。默认直接入队(queued);status='draft' 时保持草稿。
* 入队前要求主责部门已接通:派给一个没有会话的部门只会在派发阶段撞 unknown。
*/
const createTask = guard((input = {}) => {
input = preflightCreateTask(input)
const project = projectIdOf(input)
const ownerRoleId = requireRole(input.ownerRoleId, 'ownerRoleId')
const sourceRoleId = input.sourceRoleId === undefined ? 'lead' : requireRole(input.sourceRoleId, 'sourceRoleId')
const wanted = input.status === undefined ? 'queued' : input.status
if (wanted !== 'queued' && wanted !== 'draft') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `新建任务只能是 queued 或 draft,收到 ${String(wanted)}`, { field: 'status' })
}
if (wanted === 'queued') {
const binding = store.getBinding(project.id, ownerRoleId)
if (binding?.currentSessionId === null || binding?.currentSessionId === undefined) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, `${ownerRoleId} 尚未接通会话,不能直接入队;可先存草稿`, {
roleId: ownerRoleId,
hint: 'draft',
})
}
}
// 先按入队语义校验通过再取 ID:校验失败不该消耗掉一个 ID,
// 否则同一测试里连续建任务的 ID 会与预期错位。
const record = createTaskRecord({
projectId: project.id,
title: input.title,
objective: input.objective,
acceptance: optionalArray(input.acceptance, 'acceptance'),
constraints: optionalArray(input.constraints, 'constraints'),
scope: input.scope ?? null,
ownerRoleId,
sourceRoleId,
originMessageRef: optionalText(input.originMessageRef, 'originMessageRef'),
returnTarget: input.returnTarget ?? null,
}, { newTaskId: () => store.ids.task(), now: nowIso })
const queued = wanted === 'queued' ? startTask(record, { now: nowIso }) : record
return { task: copy(store.insertTask(queued)) }
})
function getTask(projectId, taskId) {
const project = projectIdOf({ projectId })
return copy(requireTask(project, taskId))
}
/** 任务列表:附开放标记与尝试/结果计数,UI 不必为每行再发请求。 */
function listTasks(projectId, filter = {}) {
const project = projectIdOf({ projectId })
if (filter.ownerRoleId !== undefined) requireRole(filter.ownerRoleId, 'ownerRoleId')
return store
.listTasks(project.id)
.filter((task) => filter.status === undefined || task.status === filter.status)
.filter((task) => filter.ownerRoleId === undefined || task.ownerRoleId === filter.ownerRoleId)
.sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)))
.map((task) => ({
...copy(task),
open: isOpenTask(task),
attemptCount: store.listAttempts(task.id).length,
resultCount: store.listResults(task.id).length,
}))
}
/**
* 取消任务。业务上立即落 cancelled,但运行的尝试只到 cancel_requested:
* 宿主取消是另一条腿,不能在这里假装已经停了(宿主记录 L6:cancel 不撤回排队消息)。
*/
const cancelTask = guard((input = {}) => {
const project = projectIdOf(input)
const task = requireTask(project, input.taskId)
const reason = input.reason === undefined ? '用户取消' : requireText(input.reason, 'reason')
const decision = cancelTaskDecision(task, reason, { now: nowIso })
const applied = applyDecision(store, task.id, decision)
let attempt = null
let cancelRequest = null
const activeId = task.activeAttemptId
if (activeId !== null && activeId !== undefined) {
const current = store.getAttempt(activeId)
if (current !== undefined && current.projectId === project.id && !isTerminal('attempt', current.state)) {
if (current.state === 'queued') {
attempt = store.updateAttempt(current.id, { state: 'cancelled', endedAt: nowIso() })
} else if (current.state === 'running') {
attempt = store.updateAttempt(current.id, { state: 'cancel_requested', cancelRequestedAt: nowIso() })
// 交给适配器去调宿主 cancel;这里只声明“该取消哪个运行”。
cancelRequest = { projectId: project.id, taskId: task.id, attemptId: current.id, hostRunId: current.hostRunId ?? null }
} else {
attempt = current
}
}
}
return {
task: copy(applied.task),
applied: applied.applied === true,
reason: applied.reason ?? null,
attempt: copy(attempt),
cancelRequest,
}
})
// ---------- 派发 ----------
/**
* dispatchTask:一次事务写三样东西——dispatch(prepared) + contextPacket + attempt(queued)。
* 三者同生共死,崩溃时不会留下“有派发没尝试”或“有尝试没交接材料”的半条记录。
*
* 幂等:同一 (projectId, idempotencyKey) 只会有一条 dispatch。
* 命中时把挂在它上面的 attempt/上下文包一起返回,duplicate=true,不新建任何记录——
* 派发可能已经投递出去,重写一条等于假装配送了两次。
*/
const dispatchTask = guard((input = {}) => {
const project = projectIdOf(input)
let task = requireTask(project, input.taskId)
const idempotencyKey = requireText(input.idempotencyKey, 'idempotencyKey')
const existing = store.findDispatchByIdempotencyKey(project.id, idempotencyKey)
if (existing !== undefined) return dispatchView(existing, true)
if (isTerminal('task', task.status)) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, `任务已终态(${task.status}),不能再次派发`, { status: task.status })
}
if (task.status === 'running') {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, '任务正在执行,派发前需先对账当前尝试', { status: task.status })
}
const targetRoleId = input.targetRoleId === undefined ? task.ownerRoleId : requireRole(input.targetRoleId, 'targetRoleId')
if (targetRoleId !== task.ownerRoleId) {
throw new ServiceError(SERVICE_CODES.DISPATCH_INVALID, '派发目标必须与任务主责部门一致', {
targetRoleId,
ownerRoleId: task.ownerRoleId,
})
}
const sourceRoleId = input.sourceRoleId === undefined ? task.sourceRoleId : requireRole(input.sourceRoleId, 'sourceRoleId')
const target = requireSeat(project, targetRoleId)
const sessionId = input.targetSessionId === undefined ? target.binding.currentSessionId : optionalText(input.targetSessionId, 'targetSessionId')
if (sessionId === null || sessionId === undefined) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, `${targetRoleId} 尚未接通会话,不能派发`, { roleId: targetRoleId })
}
if (target.binding.currentSessionId !== null && target.binding.currentSessionId !== sessionId) {
// 调用方拿着旧会话号派发:这是换绑后的典型故障,必须显式失败而不是投给新会话。
throw new ServiceError(SERVICE_CODES.SESSION_CONFLICT, 'targetSessionId 与当前绑定不一致,请重新读取席位后再派发', {
currentSessionId: target.binding.currentSessionId,
})
}
if (input.bindingGeneration !== undefined && input.bindingGeneration !== target.binding.bindingGeneration) {
throw new ServiceError(SERVICE_CODES.SESSION_CONFLICT, 'bindingGeneration 已变化,派发目标可能已被换绑', {
expected: input.bindingGeneration,
current: target.binding.bindingGeneration,
})
}
const sourceBinding = store.getBinding(project.id, sourceRoleId)
const sourceSessionId = input.sourceSessionId === undefined
? sourceBinding?.currentSessionId ?? null
: optionalText(input.sourceSessionId, 'sourceSessionId')
const packet = input.packet === undefined || input.packet === null ? {} : input.packet
if (typeof packet !== 'object' || Array.isArray(packet)) {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'packet 必须是对象', { field: 'packet' })
}
// 记忆注入:派发时把部门记忆、项目记忆与长期记忆的摘录并进交接材料,
// 部门开工前就能看到「自己以前摸出的经验」「这个项目之前发生过什么」
// 与「用户长期偏好」。记忆是参考资料:读失败不拦派发,按没有记忆处理。
let memoryExcerpts = []
if (memory !== null) {
try {
memoryExcerpts = memory.excerptsFor(project.id, task.ownerRoleId)
} catch {
memoryExcerpts = []
}
}
// 修订任务默认把「要改的那份成果 + 版本」带进交接材料:
// 主责部门不需要回头翻记录,也不会改到别的版本上。
const revisionMaterials = task.scope?.kind === 'artifact-revision' && typeof task.scope.artifactId === 'string'
? [{ artifactId: task.scope.artifactId, revision: Number(task.scope.revision ?? 1) }]
: []
// 派工本身就意味着“开始干”。草稿还停在 draft 时必须先入队:
// beginAttempt 只接受 queued/waiting_input/needs_attention/running,draft 会被拒,
// 而拒绝发生在消息已经发出之后 —— 结果是「部门收到了、账上记 unknown、任务不前进」。
// 放在所有校验之后、写账之前:校验不过就不该改动任务状态。
if (task.status === 'draft') {
task = store.updateTask({ ...task, status: 'queued', queuedAt: nowIso() })
}
const committed = store.mutate(() => {
const stamp = nowIso()
const attemptId = store.ids.attempt()
const dispatchId = store.ids.dispatch()
const contextPacketId = store.ids.contextPacket()
// 交接材料版本号:同任务内递增,重派不覆盖上一版的验收标准与摘录。
const version = [...store.state.contextPackets.values()]
.filter((row) => row.taskId === task.id)
.reduce((max, row) => Math.max(max, Number(row.version) || 0), 0) + 1
store.insertContextPacket({
id: contextPacketId,
projectId: project.id,
taskId: task.id,
version,
objective: packet.objective ?? task.objective,
acceptance: packet.acceptance === undefined ? task.acceptance : optionalArray(packet.acceptance, 'packet.acceptance'),
constraints: packet.constraints === undefined ? task.constraints : optionalArray(packet.constraints, 'packet.constraints'),
originMessageRef: packet.originMessageRef ?? task.originMessageRef,
excerpts: [...optionalArray(packet.excerpts, 'packet.excerpts'), ...memoryExcerpts],
materialRefs: normalizeMaterialRefs(
packet.materialRefs === undefined ? revisionMaterials : packet.materialRefs,
project,
),
authorizationRefs: optionalArray(packet.authorizationRefs, 'packet.authorizationRefs'),
scope: packet.scope ?? task.scope,
expectedOutputs: optionalArray(packet.expectedOutputs, 'packet.expectedOutputs'),
returnTarget: packet.returnTarget ?? task.returnTarget ?? { roleId: task.sourceRoleId },
createdAt: stamp,
})
// 注意顺序:dispatches 的引用表会校验 attemptId 与 contextPacketId,
// 所以必须先有 attempt 与上下文包,再写派发;否则 recordDispatch 会报“引用不存在”。
store.insertAttempt({
id: attemptId,
projectId: project.id,
taskId: task.id,
dispatchId: null,
// 不传 bindingId:core 的 bindings 表以 projectId+roleId 复合键存放,binding.id 不是键。
// 席位归属已由 requireSeat(project, targetRoleId) 保证。
sessionId,
hostRunId: null,
state: 'queued',
// 派发时把模型设置快照下来:之后改配置不影响这一次运行。
effectiveConfigSnapshot: {
provider: target.config.providerId,
model: target.config.modelId,
reasoningEffort: target.config.reasoningEffort ?? null,
configRevision: target.config.configRevision,
},
error: null,
createdAt: stamp,
startedAt: null,
endedAt: null,
})
const recorded = store.recordDispatch({
projectId: project.id,
taskId: task.id,
attemptId,
sourceSessionId,
targetSessionId: sessionId,
// 同上:席位归属由 requireSeat 保证,这里只记换绑护栏用的 generation。
bindingGeneration: target.binding.bindingGeneration,
contextPacketId,
idempotencyKey,
status: 'prepared',
})
// attempt 先插、派发后写:这里把 dispatchId 补回尝试,两表互指成立。
store.updateAttempt(attemptId, { dispatchId: recorded.dispatch.id })
return recorded.dispatch.id
})
return dispatchView(store.getDispatch(committed.value), false)
})
/** 把一条 dispatch 连同挂在它上面的尝试、上下文包、任务一起投影。 */
function dispatchView(dispatch, duplicate) {
const attempt = dispatch.attemptId === null ? null : store.getAttempt(dispatch.attemptId)
const packet = dispatch.contextPacketId === null ? null : store.getContextPacket(dispatch.contextPacketId)
const task = dispatch.taskId === null ? null : store.getTask(dispatch.taskId)
return {
dispatch: copy(dispatch),
attempt: copy(attempt ?? null),
contextPacket: copy(packet ?? null),
task: copy(task ?? null),
duplicate,
}
}
/** 派发状态推进(由适配器拿宿主回执驱动):走 store 的状态机,不接受跳跃。 */
const markDispatch = guard((input = {}) => {
const project = projectIdOf(input)
const dispatch = ownedRow(project, 'dispatch', input.dispatchId, 'dispatchId')
const patch = {}
if (input.status !== undefined) patch.status = input.status
if (input.hostMessageId !== undefined) patch.hostMessageId = optionalText(input.hostMessageId, 'hostMessageId')
return { dispatch: copy(store.updateDispatch(dispatch.id, patch)) }
})
// ---------- 结果 ----------
/**
* 登记尝试推进(适配器在宿主侧拿到 runId/开跑回执后调用)。
* 用 core 的 beginAttempt:任务进入 running 且 activeAttemptId 指向这次尝试。
*/
const startAttempt = guard((input = {}) => {
const project = projectIdOf(input)
// taskId 可省:Attempt 自己知道属于哪个任务。传入时必须与它对上,
// 免得 UI 拿错 ID 把别的任务推进 running。
const attempt = requireAttempt(project, input.attemptId)
const task = requireTask(project, input.taskId ?? attempt.taskId)
if (attempt.taskId !== task.id) {
throw new ServiceError(SERVICE_CODES.ATTEMPT_MISMATCH, '尝试不属于该任务', { attemptId: attempt.id })
}
const hostRunId = optionalText(input.hostRunId, 'hostRunId')
let next = attempt
if (attempt.state === 'queued') {
next = store.updateAttempt(attempt.id, { state: 'running', hostRunId, startedAt: nowIso() })
} else if (hostRunId !== null && attempt.hostRunId !== hostRunId) {
next = store.updateAttempt(attempt.id, { hostRunId })
}
// core 的 beginAttempt 只计算新对象不写库,所以这里显式落库:
// 成功即“任务进入 running 且 activeAttemptId 指向这次尝试”。
// 只把 Attempt 推到 running 是不够的:任务的 run_terminal 判定要求它当时处于 running,
// 否则"运行结束但无报告"会被当成"还在排队",needs_attention 永远落不下来。
// core 的 beginAttempt 在任务仍为 queued 时会连同任务一起推进到 running。
const decision = beginAttempt(task, next, { now: nowIso, attemptLookup: (id) => store.getAttempt(id) })
const persisted = store.updateTask(decision)
return { task: copy(persisted), attempt: copy(store.getAttempt(attempt.id)), applied: true, reason: null }
})
/**
* reportTaskResult:登记结构化结果 + 完成判定,一次事务内完成。
*
* 去重先于一切写入:同一 (attemptId, reportVersion) 或同一条 sourceMessageRef
* 只登记一次,命中时返回旧结果且 applied=false,不重跑判定、不动 revision。
*
* 判定交给 core/tasks.decide(kind:'completion'),服务层实际落地四种结果:
* 1. completed —— 报告可信 + 宿主终态 succeeded + 成果引用有效;
* 2. needs_attention—— 宿主终态 succeeded 但报告不可信(含标记了阻塞原因);
* 3. 保持不变(applied:false) —— 报告可信但宿主还没结束(candidate),等终态再定,
* 此处把报告登记进账,任务停在 running/queued,不显示已完成;
* 4. 等待结构化报告 —— 报告先到、终态后到的顺序由 reportRunTerminal 补齐。
* 任务已终态时迟到报告只登记、不改结论(stale)。
*/
const reportTaskResult = guard((input = {}) => {
const project = projectIdOf(input)
const task = requireTask(project, input.taskId)
const attempt = requireAttempt(project, input.attemptId)
if (attempt.taskId !== task.id) {
throw new ServiceError(SERVICE_CODES.ATTEMPT_MISMATCH, '尝试不属于该任务', { attemptId: attempt.id })
}
const report = input.report
if (report === null || typeof report !== 'object' || Array.isArray(report)) {
throw new ServiceError(SERVICE_CODES.REPORT_INVALID, 'report 必须是对象', { field: 'report' })
}
const summary = requireText(report.summary, 'report.summary')
const runTerminal = normalizeRunTerminal(input.runTerminal ?? report.runTerminal)
const artifactRefs = optionalArray(input.artifactRefs ?? report.artifactRefs, 'artifactRefs')
// 成果引用必须指向本项目现存成果:账上查不到就是伪造或已删,直接拒绝,不记空引用。
for (const ref of artifactRefs) {
ownedRow(project, 'artifact', ref, 'artifactRefs')
}
const sourceMessageRef = optionalText(input.sourceMessageRef, 'sourceMessageRef')
const reportVersion = input.reportVersion === undefined ? 1 : input.reportVersion
if (!Number.isInteger(reportVersion) || reportVersion < 1) {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'reportVersion 必须是正整数', { field: 'reportVersion' })
}
const blockedReason = typeof input.blockedReason === 'string' && input.blockedReason.trim() !== ''
? input.blockedReason
: (typeof report.blockedReason === 'string' && report.blockedReason.trim() !== '' ? report.blockedReason : null)
const duplicateRow = findResult(project.id, attempt.id, reportVersion, sourceMessageRef)
if (duplicateRow !== undefined) {
return {
result: copy(duplicateRow),
duplicate: true,
task: copy(store.getTask(task.id)),
decision: { applied: false, duplicate: true, reason: '结果已登记,重复事件不重新判定' },
}
}
const recorded = store.recordResult({
projectId: project.id,
taskId: task.id,
attemptId: attempt.id,
reportVersion,
summary,
artifactRefs,
checks: optionalArray(input.checks ?? report.checks, 'checks'),
remainingItems: optionalArray(input.remainingItems ?? report.remainingItems, 'remainingItems'),
blockedReason,
sourceMessageRef,
})
if (recorded.duplicate) {
return {
result: copy(recorded.result),
duplicate: true,
task: copy(store.getTask(task.id)),
decision: { applied: false, duplicate: true, reason: '结果已登记' },
}
}
// 自动记账:新成果落账后记两行——项目记忆里一行(哪个部门、做了什么),
// 主责部门自己的部门记忆里也一行(在哪个项目、做了什么),两本记忆
// 都随干活自然生长。尽力而为:写失败不影响成果本身。
if (memory !== null) {
try {
memory.appendProject(project.id, `${task.ownerRoleId} 汇报成果(任务「${task.title}」):${summary.slice(0, 500)}`)
} catch {
// 记忆是参考资料,不拖垮业务。
}
try {
const projectLabel = typeof project.displayNameCache === 'string' && project.displayNameCache !== ''
? project.displayNameCache
: project.id
memory.appendDepartment(task.ownerRoleId, `在项目「${projectLabel}」汇报成果(任务「${task.title}」):${summary.slice(0, 500)}`)
} catch {
// 同上。
}
}
if (isTerminal('task', task.status)) {
return {
result: copy(recorded.result),
duplicate: false,
task: copy(store.getTask(task.id)),
decision: { applied: false, stale: true, reason: `任务已终态(${task.status}),迟到报告只登记不判定` },
}
}
// 尝试对齐:报告意味着运行已经开始;宿主给了终态就同步落 attempt,但业务结论仍看 decide。
let liveAttempt = attempt
if (liveAttempt.state === 'queued') {
liveAttempt = store.updateAttempt(attempt.id, { state: 'running', startedAt: nowIso() })
}
if (runTerminal !== null && ATTEMPT_STATE_OF_RUN[runTerminal] !== undefined
&& !isTerminal('attempt', liveAttempt.state) && liveAttempt.state !== 'cancel_requested') {
liveAttempt = store.updateAttempt(attempt.id, { state: ATTEMPT_STATE_OF_RUN[runTerminal], endedAt: nowIso() })
}
const reportForJudge = {
taskId: task.id,
attemptId: attempt.id,
summary,
artifactRefs,
checks: optionalArray(input.checks ?? report.checks, 'checks'),
...(blockedReason === null ? {} : { blockedReason }),
}
const judged = store.mutate(() => {
const fresh = store.getTask(task.id)
// 运行还没结束:走 core 的“报告先到”分支,只登记报告时间(候选),任务保持原状态。
// 不能走 completion 判定——那会把“还没跑完”误判成 needs_attention,等于替宿主宣布结束。
if (runTerminal === null || runTerminal === 'running') {
const pending = decide(fresh, { kind: 'report', report: reportForJudge }, { now: nowIso })
if (pending.applied === true) store.updateTask(pending.task)
const summary = summarize(pending)
return {
task: store.getTask(task.id),
summary: { ...summary, reason: summary.reason ?? '报告已登记为候选,等待宿主运行结束' },
}
}
const decision = decide(fresh, {
kind: 'completion',
report: reportForJudge,
runTerminal,
artifactRefs,
artifactLookup: (ref) => store.getArtifact(ref),
}, { now: nowIso })
if (decision.applied === true) {
const applied = applyDecision(store, task.id, decision)
return { task: applied.task, summary: summarize(applied) }
}
return { task: fresh, summary: summarize(decision) }
})
return {
result: copy(recorded.result),
duplicate: false,
task: copy(judged.value.task),
attempt: copy(liveAttempt),
decision: judged.value.summary,
}
})
function findResult(projectId, attemptId, reportVersion, sourceMessageRef) {
return store.listResults(undefined)
.filter((row) => row.projectId === projectId && row.attemptId === attemptId)
.find((row) => row.reportVersion === reportVersion
|| (sourceMessageRef !== null && row.sourceMessageRef === sourceMessageRef))
}
/** 判定摘要:UI 与日志只读这几项,不解析整条任务。 */
function summarize(decision) {
const verify = decision.verdict ?? null
return {
applied: decision.applied === true,
stale: decision.stale === true,
status: decision.task?.status ?? null,
reason: decision.reason ?? null,
blockers: verify?.blockers ?? (decision.applied === true ? [] : (decision.reason === undefined ? [] : [decision.reason])),
// 三条完成条件各自的结论,UI 可逐条显示为什么还没完成。
verdict: verify === null ? null : { reportOk: verify.reportOk, runOk: verify.runOk, refsValid: verify.refsValid, ok: verify.ok },
}
}
/**
* 宿主终态单独到达(结果先到、终态后到)。只有“报告已到 + running”才会在这里完成;
* 其余按 core 的 run_terminal 分支落 needs_attention 或保持不变。
*/
const reportRunTerminal = guard((input = {}) => {
const project = projectIdOf(input)
const task = requireTask(project, input.taskId)
if (isTerminal('task', task.status)) {
// 任务已有结论(取消/完成/失败):迟到的宿主回执只能核对尝试,不能改判。
return { task: copy(task), attempt: null, decision: { applied: false, stale: true, status: task.status, reason: '任务已终态' } }
}
const runTerminal = normalizeRunTerminal(input.runTerminal)
if (runTerminal === null || runTerminal === 'running') {
return { task: copy(task), attempt: null, decision: { applied: false, status: task.status, reason: '尚未到终态' } }
}
let attempt = null
const attemptId = input.attemptId === undefined ? task.activeAttemptId : input.attemptId
if (attemptId !== null && attemptId !== undefined) {
attempt = requireAttempt(project, attemptId)
if (!isTerminal('attempt', attempt.state) && attempt.state !== 'cancel_requested'
&& ATTEMPT_STATE_OF_RUN[runTerminal] !== undefined) {
attempt = store.updateAttempt(attempt.id, { state: ATTEMPT_STATE_OF_RUN[runTerminal], endedAt: nowIso() })
}
}
const judged = store.mutate(() => {
const fresh = store.getTask(task.id)
if (runTerminal === 'running') {
// 报告正文已在 reportTaskResult 里登记,这里只需确认“仍在跑”这一事实。
return { task: fresh, summary: { applied: false, stale: false, status: fresh.status, reason: '尚未到终态' } }
}
// 运行已结束、任务却还停在 queued(适配器没来得及推进):先补一次 running,
// 否则 completion 会被状态机丢弃,任务卡在排队态,日志与 UI 都会说谎。
let live = fresh
if (live.status === 'queued') {
live = store.updateTask({ ...live, status: 'running', startedAt: nowIso() })
}
if (isTerminal('task', live.status)) {
return { task: live, summary: { applied: false, stale: true, status: live.status, reason: '任务已终态' } }
}
const report = input.report ?? latestReport(project, live, attempt?.id ?? null)
const vote = (event) => decide(live, event, { now: nowIso })
let decision
if (report !== null) {
// 报告已在账本里:按三条完成条件整体判一次(报告+终态成功+成果有效才 completed)。
decision = vote({
kind: 'completion',
report,
runTerminal,
artifactRefs: report.artifactRefs ?? [],
artifactLookup: (ref) => store.getArtifact(ref),
})
} else {
// 没收到报告、宿主却已正常结束:按"成功但无报告"记完成判定 → needs_attention
// (宿主跑完不等于业务完成,不能判 completed);failed / cancelled 各有归宿。
// 用 report: null 明确表达"确实没有报告",不靠缺省字段碰运气。
decision = vote({
kind: 'completion',
report: null,
runTerminal,
artifactRefs: [],
artifactLookup: (ref) => store.getArtifact(ref),
})
}
if (decision.applied === true) {
const applied = applyDecision(store, task.id, decision)
return { task: applied.task, summary: summarize(applied) }
}
return { task: live, summary: summarize(decision) }
})
return { task: copy(judged.value.task), attempt: copy(attempt), decision: judged.value.summary }
})
// ---------- 待补充 / 同步决定 ----------
/** requestTaskInput:明确缺什么就进入 waiting_input,只等用户补充,不广播其他部门。 */
const requestTaskInput = guard((input = {}) => {
const project = projectIdOf(input)
const task = requireTask(project, input.taskId)
const reason = requireText(input.reason, 'reason')
const missingItems = optionalArray(input.missingItems, 'missingItems')
const judged = store.mutate(() => {
const fresh = store.getTask(task.id)
const decision = decide(fresh, {
kind: 'input_required',
reason,
payload: { missingItems, scope: input.scope ?? null },
}, { now: nowIso })
if (decision.applied === true) {
const applied = applyDecision(store, task.id, decision)
return { task: applied.task, summary: summarize(applied) }
}
return { task: fresh, summary: summarize(decision) }
})
return {
task: copy(judged.value.task),
applied: judged.value.summary.applied,
reason: judged.value.summary.reason,
missingItems,
}
})
/** supplyTaskInput:用户补齐后回到原任务,不扩大范围、不新建任务。 */
const supplyTaskInput = guard((input = {}) => {
const project = projectIdOf(input)
const task = requireTask(project, input.taskId)
const judged = store.mutate(() => {
const fresh = store.getTask(task.id)
const decision = decide(fresh, { kind: 'input_supplied' }, { now: nowIso })
if (decision.applied === true) {
const applied = applyDecision(store, task.id, decision)
return { task: applied.task, summary: summarize(applied) }
}
return { task: fresh, summary: summarize(decision) }
})
return { task: copy(judged.value.task), applied: judged.value.summary.applied, reason: judged.value.summary.reason }
})
/** 取出该任务最近一次登记的结构化报告;没有就返回 null(由完成判定判成 needs_attention)。 */
function latestReport(project, task, attemptId) {
const rows = store.listResults(task.id).filter((row) => row.taskId === task.id
&& (attemptId === null || row.attemptId === attemptId))
if (rows.length === 0) return null
const last = rows.reduce((max, row) => (Number(row.reportVersion) >= Number(max.reportVersion) ? row : max), rows[0])
// taskId / attemptId 必须一起带上:core 的 validateReport 把它们当作报告可信度的一部分,
// 少一个就会判成“缺少 attemptId”,完成判定直接掉进 needs_attention。
return {
taskId: last.taskId,
attemptId: last.attemptId,
summary: last.summary,
checks: last.checks ?? [],
blockedReason: last.blockedReason ?? null,
artifactRefs: last.artifactRefs ?? [],
}
}
/**
* syncDecision:把用户在某条会话里明确同意/否决的决定,定向同步给指定任务或丞相。
* 最小实现:只登记一条带来源与选中片段的事件,不解析整段聊天、不广播给十席。
*/
const syncDecision = guard((input = {}) => {
const project = projectIdOf(input)
const content = requireText(input.content, 'content')
const sourceSessionId = optionalText(input.sourceSessionId, 'sourceSessionId')
const roleId = input.roleId === undefined ? 'lead' : requireRole(input.roleId, 'roleId')
const task = input.taskId === undefined || input.taskId === null ? null : requireTask(project, input.taskId)
const event = store.appendEvent({
type: 'decision.synced',
projectId: project.id,
roleId,
taskId: task?.id ?? null,
payload: { content, sourceSessionId, scope: input.scope ?? null, taskId: task?.id ?? null },
})
return { event: copy(event), task: copy(task), roleId }
})
// ---------- 成果 ----------
/**
* A23:成果文件被删/移走后,界面要显示「失效」而不是照旧显示可打开。
* 这里不读文件内容、不改账本,只在投影时按注入的 fileExists 探一次。
* 探不了(没接文件系统、fileRef 不是本地路径)就是 unknown,绝不猜成 ok。
*/
function artifactView(artifact) {
if (artifact === null || artifact === undefined) return null
const path = typeof artifact.fileRef === 'string' && artifact.fileRef.trim() !== '' ? artifact.fileRef.trim() : null
let existence = 'unknown'
if (path !== null && typeof fileExists === 'function') {
try {
existence = fileExists(path) ? 'ok' : 'missing'
} catch {
existence = 'unknown'
}
}
return { ...copy(artifact), existence }
}
/**
* 交接材料引用(A09):两种可追溯形态,别的一律拒绝。
* - 字符串:历史数据里的自由文本引用,原样保留
* - {artifactId}:必须是本项目的成果;版本缺省取该成果当前版本,显式给了就按给的记
* - {attachmentId}:附件的宿主侧 ID,允许带 name/mime/size 供阅读
* 显式拒绝跨项目成果引用:交接材料不能成为越权读取的通道。
*/
function normalizeMaterialRefs(value, project) {
const list = optionalArray(value, 'packet.materialRefs')
return list.map((ref, index) => {
if (typeof ref === 'string') {
if (ref.trim() === '') throw new ServiceError(SERVICE_CODES.INVALID_INPUT, '材料引用不能是空字符串', { field: `materialRefs[${index}]` })
return ref
}
if (ref === null || typeof ref !== 'object' || Array.isArray(ref)) {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, '材料引用必须是字符串或 {artifactId} / {attachmentId} 对象', {
field: `materialRefs[${index}]`,
})
}
if (typeof ref.artifactId === 'string' && ref.artifactId !== '') {
const artifact = store.getArtifact(ref.artifactId)
if (artifact === undefined) {
throw new ServiceError(SERVICE_CODES.NOT_FOUND, '材料引用指向的成果不存在', { field: `materialRefs[${index}]` })
}
if (artifact.projectId !== project.id) {
throw new ServiceError(SERVICE_CODES.CROSS_PROJECT, '材料引用指向的成果属于别的项目', {
field: `materialRefs[${index}]`,
})
}
const revision = Number.isInteger(ref.revision) && ref.revision > 0 ? ref.revision : Number(artifact.revision ?? 1)
const out = { artifactId: artifact.id, revision }
// 名字只是给人读的,默认取成果自己的显示名;显式给了就以调用方为准。
const title = typeof ref.title === 'string' && ref.title !== ''
? ref.title
: (typeof artifact.displayName === 'string' && artifact.displayName !== '' ? artifact.displayName : '')
if (title !== '') out.title = title
return out
}
if (typeof ref.attachmentId === 'string' && ref.attachmentId !== '') {
const out = { attachmentId: ref.attachmentId }
if (typeof ref.name === 'string' && ref.name !== '') out.name = ref.name
if (typeof ref.mime === 'string' && ref.mime !== '') out.mime = ref.mime
if (Number.isInteger(ref.size) && ref.size > 0) out.size = ref.size
return out
}
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, '材料引用缺少 artifactId 或 attachmentId', {
field: `materialRefs[${index}]`,
})
})
}
/** 登记成果引用:只记引用与校验结论,不复制文件内容,也不改文件本体。 */
const registerArtifact = guard((input = {}) => {
const project = projectIdOf(input)
const task = requireTask(project, input.taskId)
const ownerRoleId = input.ownerRoleId === undefined ? task.ownerRoleId : requireRole(input.ownerRoleId, 'ownerRoleId')
const sourceResultId = input.sourceResultId === undefined || input.sourceResultId === null
? null
: ownedRow(project, 'result', input.sourceResultId, 'sourceResultId').id
// 修订链:只有指向本项目既有成果才认,跨项目一律 CROSS_PROJECT。
const revisesArtifactId = input.revisesArtifactId === undefined || input.revisesArtifactId === null
? null
: ownedRow(project, 'artifact', input.revisesArtifactId, 'revisesArtifactId').id
const previous = revisesArtifactId === null ? null : store.getArtifact(revisesArtifactId)
const artifact = store.recordArtifact({
projectId: project.id,
taskId: task.id,
ownerRoleId,
fileRef: optionalText(input.fileRef, 'fileRef'),
displayName: input.displayName === undefined ? '' : String(input.displayName),
mediaType: input.mediaType === undefined ? 'application/octet-stream' : String(input.mediaType),
versionOrHash: optionalText(input.versionOrHash, 'versionOrHash'),
verification: input.verification ?? { status: 'unverified' },
sourceResultId,
revisesArtifactId,
revision: previous === null ? 1 : Number(previous.revision ?? 1) + 1,
revisionOfTaskId: previous === null ? null : (previous.revisionOfTaskId ?? previous.taskId ?? null),
})
return { artifact: artifactView(artifact) }
})
/**
* 成果修订(方案路径 B):在成果区点“找主责部门修改”,只开一条修订任务给原主责部门,
* 不重跑整套三省。任务把原成果与版本写进 scope,派发时自动进交接材料。
*/
const requestArtifactRevision = guard((input = {}) => {
const project = projectIdOf(input)
const artifact = ownedRow(project, 'artifact', input.artifactId, 'artifactId')
const instruction = requireText(input.instruction, 'instruction')
const ownerRoleId = input.ownerRoleId === undefined ? artifact.ownerRoleId : requireRole(input.ownerRoleId, 'ownerRoleId')
const sourceRoleId = input.sourceRoleId === undefined ? 'lead' : requireRole(input.sourceRoleId, 'sourceRoleId')
const wanted = input.status === undefined ? 'draft' : input.status
if (wanted !== 'queued' && wanted !== 'draft') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, `修订任务只能是 queued 或 draft,收到 ${String(wanted)}`, { field: 'status' })
}
if (wanted === 'queued') {
const binding = store.getBinding(project.id, ownerRoleId)
if (binding?.currentSessionId === null || binding?.currentSessionId === undefined) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, `${ownerRoleId} 尚未接通会话,不能直接入队;可先存草稿`, {
roleId: ownerRoleId,
hint: 'draft',
})
}
}
const record = createTaskRecord({
projectId: project.id,
title: input.title === undefined ? `修改成果:${artifact.displayName || artifact.id}` : String(input.title),
objective: instruction,
acceptance: optionalArray(input.acceptance, 'acceptance'),
constraints: optionalArray(input.constraints, 'constraints'),
scope: {
kind: 'artifact-revision',
artifactId: artifact.id,
revision: Number(artifact.revision ?? 1),
sourceTaskId: artifact.taskId ?? null,
},
ownerRoleId,
sourceRoleId,
originMessageRef: optionalText(input.originMessageRef, 'originMessageRef'),
returnTarget: input.returnTarget ?? { roleId: sourceRoleId },
}, { newTaskId: () => store.ids.task(), now: nowIso })
const withChain = {
...record,
kind: 'revision',
reviseOfArtifactId: artifact.id,
reviseOfTaskId: artifact.taskId ?? null,
artifactRevision: Number(artifact.revision ?? 1),
}
const queued = wanted === 'queued' ? startTask(withChain, { now: nowIso }) : withChain
return { task: copy(store.insertTask(queued)), artifact: artifactView(artifact) }
})
function listArtifacts(projectId) {
const project = projectIdOf({ projectId })
return store.listArtifacts(project.id).map(artifactView)
}
function getArtifact(projectId, artifactId) {
const project = projectIdOf({ projectId })
return artifactView(ownedRow(project, 'artifact', artifactId, 'artifactId'))
}
function getAttempt(projectId, attemptId) {
const project = projectIdOf({ projectId })
return copy(requireAttempt(project, attemptId))
}
// ---------- 事件 ----------
/**
* 事件轮询数据源:since 之后的本项目事件,按 seq 升序。
* - since 超出当前 seq(账本被替换/回滚)→ reset=true,前端应全量重拉而不是空等;
* - 只返回本项目事件;projectId 为空时返回全局(宿主内部用,UI 不传)。
*/
function listEvents(projectId, since = 0, optionsArg = {}) {
let scope = null
if (projectId !== undefined && projectId !== null && projectId !== '') {
scope = projectIdOf({ projectId }).id
}
const cursor = Number(since)
const start = Number.isFinite(cursor) && cursor > 0 ? Math.floor(cursor) : 0
const limit = Number.isInteger(optionsArg.limit) && optionsArg.limit > 0 ? optionsArg.limit : 200
const all = store.listEvents(scope === null ? undefined : scope)
const fresh = all.filter((row) => row.seq > start).sort((left, right) => left.seq - right.seq)
return {
events: fresh.slice(0, limit).map(copy),
seq: store.eventSeq,
reset: start > store.eventSeq,
hasMore: fresh.length > limit,
}
}
// ---------- 投影 ----------
/**
* bootstrap:一次拿全。projectId 为空时只返回项目清单,不默认选中第一个;
* 传入的项目不可见按 NOT_FOUND 报错,不泄露其他项目是否存在。
*/
function bootstrap(projectId) {
const projects = listProjects()
let selectedId = null
if (projectId !== undefined && projectId !== null && projectId !== '') {
selectedId = projectIdOf({ projectId }).id
}
if (selectedId === null) {
return {
projects,
projectId: null,
project: null,
seats: [],
layout: layout(),
tasks: [],
artifacts: [],
results: [],
eventSeq: store.eventSeq,
}
}
const project = store.getProject(selectedId)
const taskIds = new Set(store.listTasks(selectedId).map((task) => task.id))
return {
projects,
projectId: selectedId,
project: copy(project),
seats: listSeats(selectedId),
layout: layout(),
tasks: listTasks(selectedId),
artifacts: store.listArtifacts(selectedId).map(artifactView),
results: store.listResults(undefined).filter((row) => taskIds.has(row.taskId)).map(copy),
eventSeq: store.eventSeq,
}
}
// ---------- 事件:每次状态变更都写一条 outbox ----------
/**
* 哪些操作要发事件:凡是「UI 需要立刻看到」的写操作。
* 放在出口统一包一层而不是各函数里各写一遍——漏一处就是一个静默不刷新的 bug。
* syncDecision 自己已经登记了 decision.synced,这里跳过,避免同一动作两条事件。
*/
const EVENT_OPS = new Set([
'registerProject',
'bindDepartmentSession',
'releaseDepartmentSession',
'setDepartmentStatus',
'saveDepartmentConfig',
'createTask',
'cancelTask',
'dispatchTask',
'markDispatch',
'startAttempt',
'reportTaskResult',
'reportRunTerminal',
'requestTaskInput',
'supplyTaskInput',
'registerArtifact',
'requestArtifactRevision',
])
/** 从返回值里找这次写入属于哪个项目;找不到就不带项目(全局事件)。 */
function projectIdOfResult(value, input) {
const candidates = [
value?.project?.id,
value?.task?.projectId,
value?.binding?.projectId,
value?.dispatch?.projectId,
value?.attempt?.projectId,
value?.config?.projectId,
value?.artifact?.projectId,
value?.result?.projectId,
input?.projectId,
]
return candidates.find((id) => typeof id === 'string' && id !== '') ?? null
}
/**
* 事件只是“给 UI 的增量提示”,写入失败绝不能让业务失败:
* 账已经落对了,事件补不上顶多让界面晚一拍,靠 /bootstrap 仍能自愈。
*/
function emitChange(op, value, input) {
try {
const projectId = projectIdOfResult(value, input)
const roleId = value?.task?.ownerRoleId
?? value?.binding?.roleId
?? value?.attempt?.roleId
?? input?.roleId
?? null
store.appendEvent({
type: `state.${op}`,
projectId,
roleId,
taskId: value?.task?.id ?? input?.taskId ?? null,
attemptId: value?.attempt?.id ?? input?.attemptId ?? null,
payload: { op },
})
} catch {
// 见上:事件不是业务前置条件。
}
}
// ---------- 记忆 ----------
function requireMemoryScope(value) {
if (value !== 'long-term' && value !== 'project' && value !== 'department') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'scope 必须是 long-term、project 或 department', { field: 'scope' })
}
return value
}
function requireMemory() {
if (memory === null) {
throw new ServiceError(SERVICE_CODES.INVALID_STATE, '宿主未启用记忆存储')
}
return memory
}
const getMemory = guard((input = {}) => {
const scope = requireMemoryScope(input.scope)
const mem = requireMemory()
if (scope === 'long-term') {
const found = mem.readLongTerm()
return { scope, text: found.text, exists: found.exists }
}
if (scope === 'department') {
const roleId = requireRole(input.roleId, 'roleId')
const found = mem.readDepartment(roleId)
return { scope, roleId, text: found.text, exists: found.exists }
}
const project = projectIdOf(input)
const found = mem.readProject(project.id)
return { scope, projectId: project.id, text: found.text, exists: found.exists }
})
const putMemory = guard((input = {}) => {
const scope = requireMemoryScope(input.scope)
const mem = requireMemory()
if (typeof input.text !== 'string') {
throw new ServiceError(SERVICE_CODES.INVALID_INPUT, 'text 必须是字符串', { field: 'text' })
}
if (scope === 'long-term') {
mem.writeLongTerm(input.text)
return { scope, text: input.text }
}
if (scope === 'department') {
const roleId = requireRole(input.roleId, 'roleId')
mem.writeDepartment(roleId, input.text)
return { scope, roleId, text: input.text }
}
const project = projectIdOf(input)
mem.writeProject(project.id, input.text)
return { scope, projectId: project.id, text: input.text }
})
const appendMemory = guard((input = {}) => {
const scope = requireMemoryScope(input.scope)
const mem = requireMemory()
const text = requireText(input.text, 'text')
if (scope === 'long-term') {
return { scope, text: mem.appendLongTerm(text).text }
}
if (scope === 'department') {
const roleId = requireRole(input.roleId, 'roleId')
return { scope, roleId, text: mem.appendDepartment(roleId, text).text }
}
const project = projectIdOf(input)
return { scope, projectId: project.id, text: mem.appendProject(project.id, text).text }
})
const api = {
version: WORKBENCH_SERVICE_VERSION,
store,
clock,
env,
// 项目
registerProject,
listProjects,
getProject,
// 十席
listSeats,
layout,
// 绑定与配置
bindDepartmentSession,
releaseDepartmentSession,
setDepartmentStatus,
saveDepartmentConfig,
// 任务
createTask,
getTask,
listTasks,
cancelTask,
// 派发
dispatchTask,
markDispatch,
startAttempt,
// 结果
reportTaskResult,
reportRunTerminal,
requestTaskInput,
supplyTaskInput,
syncDecision,
// 记忆
getMemory,
putMemory,
appendMemory,
// 成果
registerArtifact,
requestArtifactRevision,
listArtifacts,
getArtifact,
getAttempt,
// 投影与事件
bootstrap,
listEvents,
// 供路由与测试复用
translate,
}
const wrapped = {}
for (const [name, fn] of Object.entries(api)) {
if (typeof fn !== 'function' || !EVENT_OPS.has(name)) {
wrapped[name] = fn
continue
}
wrapped[name] = (...args) => {
const value = fn(...args)
emitChange(name, value, args[0])
return value
}
}
return Object.freeze(wrapped)
}