dsh-sansheng-liubu/sansheng/src/observe.js

359 lines
14 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.

import { resolve } from 'node:path'
import { captureArtifactSnapshotSync } from './artifact.js'
import { budgetOf, evaluateGoalAction } from './gate.js'
import { resolveActor } from './identity.js'
import {
classifyGoalOutcome, describeDispatch, detectRework, isGoalMutation, newId, payloadDigestOf,
} from './records.js'
import { roleOfBot } from './roles.js'
// Q08:这些是 DSH 里真正会改用户项目的工具入口;按实际工作根加独占租约。
const WRITE_TOOLS = new Set([
'write', 'edit', 'apply_patch', 'delete', 'move', 'copy',
'write_file', 'edit_file', 'delete_file', 'move_file', 'copy_file',
'shell', 'bash', 'pwsh', 'execute', 'terminal', 'run_terminal',
'shell_command', 'run_command', 'terminal_command',
])
let rootWriteSeq = 0
function isWriteTool(name) {
return WRITE_TOOLS.has(String(name ?? ''))
}
function textOfResult(result) {
if (typeof result === 'string') return result
const content = Array.isArray(result?.content) ? result.content : []
return content.filter(part => part?.type === 'text').map(part => String(part.text ?? '')).join('\n')
}
/**
* 观测 group_goal:调用前落一条派发意图,调用后按"业务是否真的变化"补回执。
* 原生机制仍是唯一执行者;这里只记账、对账,以及在确认返工时把返工单交给工部。
* 任何记账失败都不能影响原生调用的结果。
*/
export function installObserver({ ctx, store, dsbot, bootId, isBotSession }) {
return ctx.on('tools/execute', async (exec, next) => {
if (!exec) return next()
if (isWriteTool(exec.name)) return observeWrite({ ctx, store, dsbot, exec, next, isBotSession })
if (exec.name !== 'group_goal') return next()
const action = String(exec.arguments?.action ?? '')
if (!isGoalMutation(action)) return next()
let record
let before
let project
let roomId
let replay = false
try {
const actor = resolveActor({ dsbot, store, sessionId: exec.agent?.id, isBotSession })
roomId = dsbot.roomOfSession(exec.agent?.id)
if (!roomId) {
const ref = String(exec.arguments?.group ?? '').trim()
if (ref !== '' && actor.botId) {
const picked = dsbot.pickRoom(actor.botId, ref)
if (picked.error === undefined) roomId = picked.room.id
}
}
project = roomId ? store.projectByRoom(roomId) : undefined
if (project) {
const room = dsbot.roomOf(roomId)
before = room?.goal
const stageIndex = action === 'pass' || action === 'rework' ? (before?.current ?? -1) + 1 : null
const requestId = String(exec.arguments?.request_id ?? exec.arguments?.requestId ?? '').trim() || undefined
const started = await store.beginDispatch({
id: newId('dsp'),
requestId,
payloadDigest: payloadDigestOf({ action, roomId, args: exec.arguments, actorBotId: actor.botId, stageIndex }),
bootId,
projectId: project.id,
roomId,
goalId: before?.id ?? null,
goalRevision: before?.revision ?? null,
action,
stageIndex,
actorBotId: actor.botId ?? null,
actorRole: actor.kind === 'bot' ? roleOfBot(project, actor.botId) : 'user',
actorName: actor.botName ?? null,
reason: String(exec.arguments?.reason ?? '').trim() || null,
})
record = started.record
replay = started.replay === true
if (replay) {
// 同 requestId 同 payload 的重试:不重新执行原生动作。
if (record.nativeResult?.text) return record.nativeResult.text
if (record.status === 'prepared' || record.status === 'in_flight' || record.status === 'unknown') {
return `三省六部:请求 ${record.requestId ?? record.id} 正在处理或结果未知(${record.status}),本次没有重复执行;请先用 sansheng_reconcile 核实。`
}
return record.note ?? `三省六部:请求 ${record.requestId ?? record.id} 已处理过,本次没有重复执行。`
}
try {
await store.markDispatchInFlight(record.id)
} catch (error) {
await store.finishDispatch(record.id, {
status: 'unknown',
note: `派发意图已写入,但标记 in_flight 失败:${String(error?.message ?? error)}`,
}).catch(() => {})
return `三省六部:无法标记派发 ${record.id} 为发送中(${error?.message ?? error}),本次目标修改未执行;请先核实后再重试。`
}
}
} catch (error) {
if (error?.code === 'payload-conflict') throw error
// Q05:项目已识别时,派发意图写入失败必须阻止原生命令执行。
// 不能“记账失败就继续”,否则执行了却没有可对账的记录。
if (project) {
return `三省六部:无法写入派发记录(${error?.message ?? error}),本次目标修改未执行;请恢复存储后重试。`
}
record = undefined
}
// Q06/G06:guard 通过后到真正执行还有异步窗口;若 guard 打过标记,
// 在 next() 前用最新 reviews/artifact 再判一次,防止审批在窗口里被撤销/成果变化。
if (record && project && exec.__sanshengGate === true) {
try {
const reason = finalGateReason({ store, dsbot, exec, project, roomId, isBotSession })
if (reason) {
await store.finishDispatch(record.id, { status: 'rejected', note: reason }).catch(() => {})
return `三省六部:${reason}`
}
} catch (error) {
await store.finishDispatch(record.id, {
status: 'unknown',
note: `最终复核失败:${String(error?.message ?? error)}`,
}).catch(() => {})
return `三省六部:最终复核失败(${error?.message ?? error}),本次目标修改未执行。`
}
}
let result
try {
result = await next()
} catch (error) {
if (record) {
try {
await store.finishDispatch(record.id, {
status: 'unknown',
note: `原生调用抛出异常,结果未知:${String(error?.message ?? error)}`,
})
} catch { /* 记账失败不影响调用 */ }
}
throw error
}
if (record) {
try {
await settle({ ctx, store, dsbot, project, record, action, result, before, roomId })
} catch (error) {
// 原生调用已经返回,但回执写入失败:不能把 in_flight 留成“看似成功”。
// 尽力改成 unknown,交给 sansheng_reconcile;若存储仍不可用,下次启动对账会处理。
try {
await store.finishDispatch(record.id, {
status: 'unknown',
note: `原生调用已返回,但派发回执记录失败:${String(error?.message ?? error)}`,
})
} catch { /* 下次启动 reconcile 会把 prepared/in_flight 标为 unknown */ }
}
}
return result
})
}
async function observeWrite({ ctx, store, dsbot, exec, next, isBotSession }) {
const actor = resolveActor({ dsbot, store, sessionId: exec.agent?.id, isBotSession })
if (actor.kind !== 'bot' || !actor.project || actor.projectConflict) return next()
const project = actor.project
if (!project.workDir) return next()
const root = resolve(project.workDir)
const holder = `${actor.botId}:${exec.id ?? exec.agent?.id ?? 'write'}:${++rootWriteSeq}`
let lease
try {
lease = await store.acquireRootLease(root, { holder, taskId: String(exec.id ?? exec.arguments?.task ?? 'write') })
} catch (error) {
return `三省六部:无法建立工作根写租约(${error?.message ?? error}),本次文件写未执行。`
}
if (!lease.ok) return `三省六部:${lease.reason} 本次文件写未执行。`
const renew = setInterval(() => {
store.acquireRootLease(root, { holder, taskId: String(exec.id ?? exec.arguments?.task ?? 'write') }).catch(() => {})
}, 5 * 60 * 1000)
renew.unref?.()
let background = false
try {
const result = await next()
// Q08:后台 job 的工具调用一返回,宿主的执行已经结束但工作还在跑。
// 有 ctx.jobs 就把租约交给 job 的 wait,等 job 真正结束后再释放。
const jobId = backgroundJobIdOf(result)
let jobs
try { jobs = ctx.get?.('jobs', false) } catch { jobs = undefined }
if (jobId && jobs && typeof jobs.wait === 'function') {
const sessionId = exec.agent?.id
try {
const waiter = jobs.wait(jobId, 24 * 60 * 60 * 1000, sessionId)
background = true
void Promise.resolve(waiter)
.catch(() => undefined)
.finally(async () => {
clearInterval(renew)
await store.releaseRootLease(root, holder).catch(() => {})
})
} catch {
// wait 同步拒绝时退回普通释放路径。
}
}
return result
} finally {
if (!background) {
clearInterval(renew)
// 真实执行结束、抛错或取消都释放;进程被杀时最多留到租约过期。
await store.releaseRootLease(root, holder).catch(() => {})
}
}
}
/** DSH 后台 job id 形如 `<kind>-<16 hex>`;只认工具结果里明确出现的 id。 */
function backgroundJobIdOf(result) {
const direct = result?.jobId ?? result?.job?.id
if (typeof direct === 'string' && direct.trim() !== '') return direct.trim()
const text = textOfResult(result)
const match = text.match(/\b([a-z][a-z0-9-]*-[0-9a-f]{16})\b/i)
return match?.[1]
}
function finalGateReason({ store, dsbot, exec, project, roomId, isBotSession }) {
const room = dsbot.roomOf(roomId)
const goal = room?.goal
const action = String(exec.arguments?.action ?? '')
const actor = resolveActor({ dsbot, store, sessionId: exec.agent?.id, isBotSession })
const members = (room?.members ?? []).map(id => ({
id,
name: dsbot.botOf(id)?.name ?? id,
role: roleOfBot(project, id),
}))
let artifact
if (project.workDir && (action === 'pass' || action === 'complete')) {
artifact = captureArtifactSnapshotSync({
project,
goal,
stageIndex: action === 'complete' ? null : (goal?.current ?? -1) + 1,
scope: action === 'complete' ? 'goal' : 'stage',
})
}
const health = typeof store.health === 'function' ? store.health() : { status: 'ok' }
const verdict = evaluateGoalAction({
action,
actor: { ...actor, role: roleOfBot(project, actor.botId) },
project,
goal,
reviews: store.peek().reviews,
reworks: store.peek().reworks,
members,
args: exec.arguments ?? {},
artifact,
projectFreshness: health.status,
})
return verdict.allow ? undefined : verdict.reason
}
async function settle({ ctx, store, dsbot, project, record, action, result, before, roomId }) {
const after = roomId ? dsbot.roomOf(roomId)?.goal : undefined
const outcome = classifyGoalOutcome({ action, before, after, result })
const revisionAfter = after?.revision ?? null
await store.finishDispatch(record.id, {
status: outcome.status,
revisionAfter,
nativeResult: { ok: outcome.status === 'confirmed', text: textOfResult(result).slice(0, 1000) },
note: outcome.note,
})
await store.addEvent({
kind: 'dispatch',
projectId: project.id,
summary: describeDispatch({ ...record, status: outcome.status }),
action,
status: outcome.status,
})
if (outcome.status !== 'confirmed' || action !== 'rework') return
const detected = detectRework({ before, after, reason: record.reason })
if (!detected) return
const budget = budgetOf(after, project, store.peek().reworks)
const rework = {
id: newId('rwk'),
projectId: project.id,
goalId: after.id,
stageIndex: detected.stageNo,
stageTitle: detected.stageTitle,
reason: detected.reason,
goalRevision: revisionAfter,
revisionAfter,
budgetUsed: budget.used,
budgetMax: budget.max,
at: Date.now(),
}
const added = await store.addRework(rework)
if (added.duplicate) return
if (project.autoRework === false) return
const rt = ctx.get('dsbot-runtime', false)
if (!rt || typeof rt.deliver !== 'function') return
const room = dsbot.roomOf(roomId)
const sessionId = room?.sessions?.[project.bots?.gongbu]
const text = [
`阶段 ${detected.stageNo}「${detected.stageTitle}」被驳回,请返工。`,
detected.reason === '' ? '' : `驳回原因:${detected.reason}`,
`这是第 ${budget.used}/${budget.max} 轮返工;完成后在群里 @尚书 回报,附改动与测试证据。`,
].filter(line => line !== '').join('\n')
// 自动返工是独立于 group_goal 的一次派发:稳定 requestId 保证同一目标版本只发一次。
const requestId = `rwk:${after.id}:${revisionAfter}:${project.bots?.gongbu ?? ''}`
let dispatch
try {
const started = await store.beginDispatch({
id: newId('dsp'),
requestId,
payloadDigest: payloadDigestOf({ action: 'auto_rework', roomId, args: { text }, actorBotId: project.bots?.shangshu, stageIndex: detected.stageNo }),
bootId: record.bootId,
projectId: project.id,
roomId,
goalId: after.id,
goalRevision: revisionAfter,
action: 'auto_rework',
stageIndex: detected.stageNo,
actorBotId: project.bots?.shangshu ?? null,
actorRole: 'shangshu',
actorName: null,
reason: detected.reason,
})
dispatch = started.record
if (started.replay) {
await store.finishDispatch(record.id, { autoRework: 'already-delivered' })
return
}
await store.markDispatchInFlight(dispatch.id)
} catch {
await store.finishDispatch(record.id, { autoRework: 'intent-failed' })
return
}
try {
await rt.deliver({
fromId: project.bots.shangshu,
toId: project.bots.gongbu,
sessionId,
roomId,
text,
role: 'request',
note: '返工派单',
})
await store.finishDispatch(dispatch.id, {
status: 'confirmed',
nativeResult: { ok: true, text: '返工消息已交给工部 Session。' },
})
await store.finishDispatch(record.id, { autoRework: 'delivered' })
} catch (error) {
// 失败可能发生在消息已入队之后:记为 unknown,不自动重发,交给 sansheng_reconcile。
await store.finishDispatch(dispatch.id, {
status: 'unknown',
note: `返工投递异常,结果未知:${String(error?.message ?? error)}`,
})
await store.finishDispatch(record.id, { autoRework: `unknown: ${String(error?.message ?? error)}` })
}
}