1584 lines
70 KiB
JavaScript
1584 lines
70 KiB
JavaScript
// 工作台业务服务:纯业务,不碰 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)
|
||
}
|