diff --git a/src/main/ipc/registry.ts b/src/main/ipc/registry.ts index 4b5b6ef41..df6986396 100644 --- a/src/main/ipc/registry.ts +++ b/src/main/ipc/registry.ts @@ -21,6 +21,22 @@ export type RegisteredIpcHandler = ( ...args: any[] ) => any; +/** + * P0-a (#149): true when the invoke arrived over the gateway instead of a + * renderer. Discriminates on the frozen REQ-A-13 shape — a synthetic gateway + * event carries `gateway.clientId` with null sender/senderFrame, a renderer + * invoke has a real sender frame and no `gateway`. Handlers that record WHO + * acted must derive the status-event actor from this discriminator instead of + * assuming the caller: a gateway invoke is the chair acting remotely, a + * renderer invoke is the owner's UI action. + */ +export function isGatewayInvokeEvent( + event: IpcMainInvokeEvent | SyntheticGatewayInvokeEvent, +): event is SyntheticGatewayInvokeEvent { + const candidate = event as Partial; + return typeof candidate.gateway?.clientId === 'string'; +} + const handlers = new Map(); /** diff --git a/src/main/main.ts b/src/main/main.ts index 26c1ed8b6..53cf9655d 100644 --- a/src/main/main.ts +++ b/src/main/main.ts @@ -23,7 +23,7 @@ import { runServerBootstrap, ServerBootstrapStore, type ServerBootstrapRun } fro import { createServerBootstrapFacts, createServerBootstrapStepExecutors } from './server/bootstrapSteps'; import { SqliteStore } from './sqliteStore'; import { isAllowedPaymentLaunchUrl } from './paymentLaunchUrl'; -import { registerIpcHandler } from './ipc/registry'; +import { isGatewayInvokeEvent, registerIpcHandler } from './ipc/registry'; import { broadcastToRenderers } from './ipc/broadcast'; import { listPendingPermissions, @@ -16895,7 +16895,7 @@ if (!gotTheLock) { } }); - registerIpcHandler('groupTask:close', async (_event, input: { taskId?: number; status?: string; reason?: string; rating?: number; ratingComment?: string }) => { + registerIpcHandler('groupTask:close', async (event, input: { taskId?: number; status?: string; reason?: string; rating?: number; ratingComment?: string }) => { try { const taskId = Number(input?.taskId); if (!Number.isInteger(taskId) || taskId <= 0) { @@ -16921,8 +16921,13 @@ if (!gotTheLock) { reason: typeof input?.reason === 'string' ? input.reason : undefined, rating, ratingComment, - // The UI close action is the owner's — recorded on the status event. - actor: { kind: 'owner' }, + // P0-a (#149): derive the status-event actor from the invoke + // discriminator (REQ-A-13) instead of assuming the caller — a + // gateway invoke (gateway.clientId) is the chair closing remotely, + // a renderer invoke (senderFrame) is the owner's UI action. + // Hardcoding 'owner' here used to record the chair's remote closes + // as owner acceptance while the UI showed the owner hint for both. + actor: isGatewayInvokeEvent(event) ? { kind: 'chair' } : { kind: 'owner' }, })); broadcastGroupTaskEvent({ type: 'groupTask:statusChanged', taskId, status: task.status, at: Date.now() }); return { success: true, task }; @@ -16931,18 +16936,22 @@ if (!gotTheLock) { } }); - registerIpcHandler('groupTask:reopen', async (_event, input: { taskId?: number; reason?: string }) => { + registerIpcHandler('groupTask:reopen', async (event, input: { taskId?: number; reason?: string }) => { try { const taskId = Number(input?.taskId); if (!Number.isInteger(taskId) || taskId <= 0) { throw new Error('taskId is required'); } - // P0-1: review -> executing 补充执行通道 (Back to work). Owner-only UI - // action; the chair reopens via the on-chain [STATUS:EXECUTING] tag. + // P0-1: review -> executing 补充执行通道 (Back to work). The chair + // normally reopens via the on-chain [STATUS:EXECUTING] tag, but the + // gateway allowlist exposes this channel too (all groupTask:* are P2), + // so the actor is derived from the invoke discriminator the same way as + // groupTask:close (P0-a #149) — renderer invoke = owner, gateway + // invoke = chair; never assumed. const task = await withSqliteRecovery('groupTask:reopen', () => reopenGroupTask(taskId, { reason: typeof input?.reason === 'string' ? input.reason : undefined, - actor: { kind: 'owner' }, + actor: isGatewayInvokeEvent(event) ? { kind: 'chair' } : { kind: 'owner' }, })); broadcastGroupTaskEvent({ type: 'groupTask:statusChanged', taskId, status: task.status, at: Date.now() }); return { success: true, task }; diff --git a/src/main/services/groupTaskOrchestrationBridge.ts b/src/main/services/groupTaskOrchestrationBridge.ts index c52ebdba4..ea5fb4f50 100644 --- a/src/main/services/groupTaskOrchestrationBridge.ts +++ b/src/main/services/groupTaskOrchestrationBridge.ts @@ -9,6 +9,7 @@ import { GroupTaskStore, type GroupTask, type GroupTaskDeliverable, + type GroupTaskDeliverableStatus, type GroupTaskStatusEventActor, } from '../groupTaskStore'; import { recordDeliverableVerdictImpression } from './openTeamImpressionService'; @@ -500,19 +501,34 @@ export class GroupTaskOrchestrationBridge { } this.deps.orchestrationStore.updateStepStatus(step.id, 'completed', { acceptedResult: accepted }); } + // P0-b (task #149): acceptance is the OWNER's verdict. A chair close (the + // bearer RPC path) or any other non-owner accept must NOT write + // deliverable.status='accepted' on the owner's behalf — that flipped the + // ledger to "owner accepted" with nobody having accepted. Non-owner done + // closes flip pending rows to 'delivered' instead: the rows stay visible + // in the acceptance summary and member readouts (both filter + // delivered||accepted), and the chair's closure_note carries the + // "closed on behalf, owner acceptance pending" semantics. The verdict + // impression below is likewise owner-only — it records the OWNER's + // verdict, and recording it for a chair close would sediment the same + // false acceptance into the remote collaborator's culture base. + const ownerAccepting = actor?.kind === 'owner'; + const closeVerdict: GroupTaskDeliverableStatus = ownerAccepting ? 'accepted' : 'delivered'; for (const deliverable of this.deps.groupTaskStore.listDeliverables(groupTask.id)) { if (deliverable.status === 'pending') { - this.deps.groupTaskStore.updateDeliverableStatus(deliverable.id, 'accepted'); + this.deps.groupTaskStore.updateDeliverableStatus(deliverable.id, closeVerdict); // OpenTeam M3: the chair sediments a delivery impression for REMOTE // authors (local authors are covered by the canonical attempt // projection in recordDeliverable plus the dream pipeline). // Best-effort, never throws. - recordDeliverableVerdictImpression( - groupTask.id, - deliverable.authorGlobalmetaid ?? '', - 'accepted', - deliverable.uri, - ); + if (ownerAccepting) { + recordDeliverableVerdictImpression( + groupTask.id, + deliverable.authorGlobalmetaid ?? '', + 'accepted', + deliverable.uri, + ); + } } } canonical = this.deps.orchestrationStore.getTask(canonical.id)!; diff --git a/src/main/services/groupTaskService.ts b/src/main/services/groupTaskService.ts index b2ebc7489..6ea4cff62 100644 --- a/src/main/services/groupTaskService.ts +++ b/src/main/services/groupTaskService.ts @@ -2865,9 +2865,16 @@ export async function closeGroupTask( const chair = getMetabotStore().getMetabotById(closed.chairMetabotId); if (closed.groupId && chair) { await sendGroupChatMessageFn(closed.chairMetabotId, closed.groupId, { + // P0-b (task #149): the done close-out must not claim owner + // acceptance when the closer was not the owner — a chair RPC close + // used to announce "accepted by the owner" while the ledger only + // carried delivered rows awaiting the owner's verdict. The owner's + // own close (UI path) keeps the acceptance wording. content: (closed.status === 'done' - ? '[STATUS:DONE] Task closed: accepted by the owner.' + ? (opts.actor?.kind === 'owner' + ? '[STATUS:DONE] Task closed: accepted by the owner.' + : '[STATUS:DONE] Task closed: closed by the chair on behalf of the owner; owner acceptance pending.') : '[STATUS:CANCELLED] Task closed: cancelled by the owner.') + (opts.reason?.trim() ? ` Reason: ${opts.reason.trim()}` : ''), nickName: chair.name?.trim() || `bot-${closed.chairMetabotId}`, diff --git a/src/renderer/components/groupTasks/GroupTaskDetailView.tsx b/src/renderer/components/groupTasks/GroupTaskDetailView.tsx index 5f639903f..e26e86ad1 100644 --- a/src/renderer/components/groupTasks/GroupTaskDetailView.tsx +++ b/src/renderer/components/groupTasks/GroupTaskDetailView.tsx @@ -544,6 +544,16 @@ const GroupTaskDetailView: React.FC = ({ ), [members], ); + // P0-a (#149): the accepted-hint tier reads the PERSISTED ledger actor — the + // actor_kind of the last close-to-done status event (statusEvents is newest + // first, so find() takes the latest) — never session state or UI inference. + // 'chair' tiers the hint to the chair's proxy close; any other ledger actor + // (owner, system, or legacy rows without status events) keeps the owner copy. + const acceptedActorKind = useMemo<'owner' | 'chair' | 'system'>( + () => (detail && Array.isArray(detail.statusEvents) ? detail.statusEvents : []) + .find((event) => event.toStatus === 'done')?.actorKind ?? 'owner', + [detail], + ); // P13 (v1.1): the roster wins over the chain nickname. A worker session can // post under a runtime identity nickname (task #22 rendered Builder阿码's // delivery as "claude bot"), while senderGlobalMetaId always points at the @@ -1087,8 +1097,14 @@ const GroupTaskDetailView: React.FC = ({ : deliverable.status === 'delivered' ? 'groupTasksDeliverableStatusDelivered' : 'groupTasksDeliverableStatusPending'; + // P0-a (#149): the accepted hint tiers on the ledger actor + // (acceptedActorKind above): owner acceptance keeps the + // owner copy, a chair proxy close gets its own copy that + // must not claim owner acceptance. const statusHintKey = deliverable.status === 'accepted' - ? 'groupTasksDeliverableStatusAcceptedHint' + ? (acceptedActorKind === 'chair' + ? 'groupTasksDeliverableStatusAcceptedHintByChair' + : 'groupTasksDeliverableStatusAcceptedHint') : deliverable.status === 'rejected' ? 'groupTasksDeliverableStatusRejectedHint' : deliverable.status === 'delivered' diff --git a/src/renderer/services/i18n.ts b/src/renderer/services/i18n.ts index 13eb41ad6..04c03cb65 100644 --- a/src/renderer/services/i18n.ts +++ b/src/renderer/services/i18n.ts @@ -2625,6 +2625,7 @@ const translations: Record> = { groupTasksDeliverableStatusPendingHint: '已提交,待 owner 验收(与链上确认是两个独立维度)', groupTasksDeliverableStatusDeliveredHint: '链上核验通过,待 owner 验收', groupTasksDeliverableStatusAcceptedHint: '已通过 owner 验收', + groupTasksDeliverableStatusAcceptedHintByChair: '已由主席代为关闭——最终验收待定', groupTasksDeliverableStatusRejectedHint: '已被拒绝', groupTasksDeliverableViewSource: '查看原文', groupTasksDeliverableNoSource: '(无正文)', @@ -6457,6 +6458,7 @@ const translations: Record> = { groupTasksDeliverableStatusPendingHint: 'Submitted, awaiting owner acceptance (independent from on-chain confirmation)', groupTasksDeliverableStatusDeliveredHint: 'Verified on-chain, awaiting owner acceptance', groupTasksDeliverableStatusAcceptedHint: 'Accepted by the owner', + groupTasksDeliverableStatusAcceptedHintByChair: 'Closed by the chair (proxy close) — final acceptance pending', groupTasksDeliverableStatusRejectedHint: 'Rejected', groupTasksDeliverableViewSource: 'View source message', groupTasksDeliverableNoSource: '(no body)', diff --git a/tests/groupTaskAcceptanceActorGate.test.mjs b/tests/groupTaskAcceptanceActorGate.test.mjs new file mode 100644 index 000000000..a05161772 --- /dev/null +++ b/tests/groupTaskAcceptanceActorGate.test.mjs @@ -0,0 +1,398 @@ +/** + * P0-b (task #149) — acceptance semantics gate on acceptGroupTask: + * acceptance (deliverable.status='accepted' + the owner verdict impression) + * is the OWNER's act. A chair close (the bearer RPC path) or any other + * non-owner done close flips pending rows to 'delivered' instead — the rows + * stay visible in the acceptance summary and member readouts (both filter + * delivered||accepted) and the chair's closure note carries the "closed on + * behalf, owner acceptance pending" semantics. + * + * Covered here: + * 1. chair close: pending -> delivered, no 'accepted' row, chair close-out + * announcement (never the "accepted by the owner" wording); + * 2. owner close: pending -> accepted, owner announcement wording; + * 3. no-actor accept (syncStatus/heal shape): pending -> delivered; + * 4. verdict impression: owner close records it for the remote author, a + * chair close records none; + * 5. reopen (chair and owner actors): no deliverable write at all; + * 6. no-bridge fallback close: deliverables untouched (stay 'pending'); + * 7. heal sweep: the system catch-up lands 'delivered' (system is not the + * owner). + * + * Harness mirrors groupTaskReopenAndStatus.test.mjs (electron mock + real + * stores) and the impression wiring of openTeamImpressionService.test.mjs. + * No on-chain calls; the transport is a capturing stub. + */ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; +import { createRequire } from 'node:module'; +import Module from 'node:module'; + +const require = createRequire(import.meta.url); + +const originalLoad = Module._load; +Module._load = function patchedLoad(request, ...rest) { + if (request === 'electron') { + return { + app: { + isPackaged: false, + getAppPath: () => process.cwd(), + getPath: () => process.cwd(), + }, + }; + } + return originalLoad.call(this, request, ...rest); +}; + +const { SqliteStore } = require('../dist-electron/main/sqliteStore.js'); +const { MetabotStore } = require('../dist-electron/main/metabotStore.js'); +const { GroupTaskStore } = require('../dist-electron/main/groupTaskStore.js'); +const { OrchestrationStore } = require('../dist-electron/main/orchestrationStore.js'); +const { MetaIDExperienceStore } = require('../dist-electron/main/metaidExperienceStore.js'); +const { MetaIDImpressionStore } = require('../dist-electron/main/metaidImpressionStore.js'); +const { CoworkStore } = require('../dist-electron/main/coworkStore.js'); +const { GroupTaskOrchestrationBridge } = require('../dist-electron/main/services/groupTaskOrchestrationBridge.js'); +const groupTaskService = require('../dist-electron/main/services/groupTaskService.js'); +const impressionService = require('../dist-electron/main/services/openTeamImpressionService.js'); + +Module._load = originalLoad; + +const { + closeGroupTask, + reopenGroupTask, + setGroupTaskServiceMetabotStoreGetter, + setGroupTaskServiceGroupTaskStoreGetter, + setGroupTaskServiceOrchestrationBridgeGetter, + setGroupTaskServiceKvStoreGetter, + setGroupTaskServiceCoworkStoreGetter, + setGroupTaskServiceTransport, + resetGroupTaskServiceTransport, +} = groupTaskService; + +const { setOpenTeamImpressionServiceDepsGetter } = impressionService; + +const GROUP_ID = 'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffff00000000i0'; +// Valid GlobalMetaID format (the impression store validates the shape; the +// task-side ids above are free-form). Same constants as +// openTeamImpressionService.test.mjs. +const CHAIR = 'idq1chair00000000000000000000000000000000'; +const WORKER = 'idq1worker000000000000000000000000000000'; +const REMOTE_A = 'idq1remotea00000000000000000000000000000'; + +const makeTempDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'idbots-p0b-accept-gate-')); + +const insertWallet = (db, id) => { + db.run( + `INSERT INTO metabot_wallets (id, mnemonic, path, created_at) + VALUES (?, ?, ?, ?)`, + [id, `abandon ability able about above absent absorb abstract absurd abuse access accident ${id}`, "m/44'/10001'/0'/0/0", 1700000000000 + id], + ); +}; + +const insertMetabot = (db, { id, walletId, name, type = 'worker', globalmetaid = null, bossGmid = null }) => { + db.run( + `INSERT INTO metabots ( + id, wallet_id, mvc_address, btc_address, doge_address, public_key, chat_public_key, + name, enabled, metaid, globalmetaid, metabot_type, created_by, role, soul, + boss_global_metaid, allow_chat_skills, created_at, updated_at + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + [ + id, walletId, `mvc-${id}`, `btc-${id}`, `doge-${id}`, `public-${id}`, `chat-public-${id}`, + name, 1, `metaid-${id}`, globalmetaid, type, '0000', `${name} role`, `${name} soul`, + bossGmid, null, 1700000000000 + id, 1700000000000 + id, + ], + ); +}; + +const createHarness = async ({ withBridge = true } = {}) => { + const tempDir = makeTempDir(); + const store = await SqliteStore.create(tempDir); + const db = store.getDatabase(); + const metabotStore = new MetabotStore(db, store.getSaveFunction()); + const groupTaskStore = new GroupTaskStore(db, store.getSaveFunction()); + const orchestrationStore = new OrchestrationStore(db, store.getSaveFunction()); + const experienceStore = new MetaIDExperienceStore(db, store.getSaveFunction()); + const impressionStore = new MetaIDImpressionStore(db, store.getSaveFunction()); + const coworkStore = new CoworkStore(db, () => {}); + + insertWallet(db, 1); + // bossGmid binds the owner GlobalMetaID — ensureCanonicalTask derives the + // canonical card's owner from the chair twin's boss binding. + insertMetabot(db, { id: 1, walletId: 1, name: 'Twin Bot', type: 'twin', globalmetaid: CHAIR, bossGmid: 'gmid-boss' }); + insertMetabot(db, { id: 2, walletId: 1, name: 'Coder Bot', globalmetaid: WORKER }); + + const bridge = new GroupTaskOrchestrationBridge({ + groupTaskStore, + orchestrationStore, + getMetabotById: (id) => metabotStore.getMetabotById(id), + }); + + const sends = []; + setGroupTaskServiceMetabotStoreGetter(() => metabotStore); + setGroupTaskServiceGroupTaskStoreGetter(() => groupTaskStore); + setGroupTaskServiceOrchestrationBridgeGetter(withBridge ? () => bridge : null); + setGroupTaskServiceKvStoreGetter(() => store); + setGroupTaskServiceCoworkStoreGetter(() => coworkStore); + setGroupTaskServiceTransport({ + createGroupChat: async () => ({ groupId: GROUP_ID, pinId: GROUP_ID }), + joinGroupChat: async (metabotId) => ({ pinId: `join-pin-${metabotId}` }), + joinGroupChatAsIdentity: async () => ({ pinId: 'owner-join-pin' }), + sendGroupChatMessage: async (metabotId, groupId, opts) => { + sends.push({ metabotId, groupId, content: opts?.content ?? '' }); + return { pinId: `send-pin-${sends.length}` }; + }, + sendGroupChatMessageAsIdentity: async () => ({ pinId: 'identity-send-pin' }), + waitForGroupIndexed: async () => true, + }); + + const wireImpressionDeps = () => setOpenTeamImpressionServiceDepsGetter(() => ({ + groupTaskStore, + experienceStore, + impressionStore, + getMetabotById: (id) => metabotStore.getMetabotById(id), + now: () => 1_800_000_000_000, + })); + + // group_tasks.group_id is UNIQUE — every task in one harness needs its own + // group id (same shape: 64 hex chars + 'i0'). + const createTask = (status = 'review', groupId = GROUP_ID) => { + const task = groupTaskStore.createTask({ + groupId, title: 'Build MetaApp', goal: 'Ship the intro MetaApp', + chairMetabotId: 1, createdBy: 'user', + }); + groupTaskStore.addMember({ taskId: task.id, metabotId: 1, globalmetaid: CHAIR, role: 'chair' }); + groupTaskStore.addMember({ taskId: task.id, metabotId: 2, globalmetaid: WORKER, role: 'worker' }); + if (status !== 'planning') { + groupTaskStore.updateTaskStatus(task.id, 'executing', { actor: { kind: 'chair' } }); + if (status !== 'executing') { + groupTaskStore.updateTaskStatus(task.id, status, { actor: { kind: 'chair' } }); + } + } + return task; + }; + + const addRemoteWorker = (taskId) => { + groupTaskStore.addMember({ taskId, metabotId: null, globalmetaid: REMOTE_A, role: 'worker', displayName: 'Remote Bot A' }); + }; + + const pendingDeliverable = (taskId, authorGlobalmetaid = WORKER, uri = 'metaapp://p0b-gate') => + groupTaskStore.addDeliverable({ taskId, msgPinId: null, authorGlobalmetaid, kind: 'metaapp', uri }); + + const verdictObservations = (subject) => + impressionStore.listObservations({ observerGlobalMetaID: CHAIR, subjectGlobalMetaID: subject }) + .filter((observation) => observation.idempotencyKey?.startsWith('openteam:deliverable-verdict:')); + + const closeAnnouncements = () => sends.filter((send) => /^\[STATUS:/.test(send.content)); + + return { + store, db, metabotStore, groupTaskStore, orchestrationStore, experienceStore, impressionStore, + bridge, sends, createTask, addRemoteWorker, pendingDeliverable, wireImpressionDeps, + verdictObservations, closeAnnouncements, + cleanup: () => { + setOpenTeamImpressionServiceDepsGetter(null); + setGroupTaskServiceOrchestrationBridgeGetter(null); + resetGroupTaskServiceTransport(); + store.close(); + }, + }; +}; + +// --------------------------------------------------------------------------- +// 1+2: chair close lands 'delivered'; owner close lands 'accepted' +// --------------------------------------------------------------------------- + +test('P0-b: chair close flips pending deliverables to delivered (never accepted) and announces the chair wording', async () => { + const h = await createHarness(); + try { + const task = h.createTask('review'); + const first = h.pendingDeliverable(task.id); + const second = h.pendingDeliverable(task.id, WORKER, 'metaapp://p0b-gate-2'); + + const closed = await closeGroupTask(task.id, { + status: 'done', + actor: { kind: 'chair' }, + closureNote: 'chair closed on behalf of the owner; owner acceptance pending', + }); + assert.equal(closed.status, 'done'); + + const rows = h.groupTaskStore.listDeliverables(task.id); + assert.ok(rows.length >= 2); + for (const row of [first, second]) { + const fresh = rows.find((item) => item.id === row.id); + assert.equal(fresh.status, 'delivered', 'chair close lands delivered'); + assert.notEqual(fresh.status, 'accepted', 'chair close never writes accepted'); + } + + const announcements = h.closeAnnouncements(); + assert.equal(announcements.length, 1, 'exactly one close-out announcement'); + assert.ok( + announcements[0].content.includes('closed by the chair on behalf of the owner; owner acceptance pending'), + 'chair close-out carries the on-behalf wording', + ); + assert.ok( + !announcements[0].content.includes('accepted by the owner'), + 'chair close-out never claims owner acceptance', + ); + + // delivered rows keep the member readout honest: the author settles to + // done (the delivered||accepted filter in getGroupTask). + const coder = closed.members.find((member) => member.metabotId === 2); + assert.equal(coder.status, 'done', 'delivered rows still settle the author member'); + } finally { + h.cleanup(); + } +}); + +test('P0-b: owner close keeps flipping pending deliverables to accepted (owner wording announcement)', async () => { + const h = await createHarness(); + try { + const task = h.createTask('review'); + const deliverable = h.pendingDeliverable(task.id); + + const closed = await closeGroupTask(task.id, { status: 'done', actor: { kind: 'owner' } }); + assert.equal(closed.status, 'done'); + const fresh = h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id); + assert.equal(fresh.status, 'accepted', 'owner close lands accepted'); + + const announcements = h.closeAnnouncements(); + assert.equal(announcements.length, 1); + assert.ok( + announcements[0].content.includes('accepted by the owner'), + 'owner close keeps the acceptance wording', + ); + } finally { + h.cleanup(); + } +}); + +// --------------------------------------------------------------------------- +// 3: no-actor accept (syncStatus done-branch / heal shape) lands delivered +// --------------------------------------------------------------------------- + +test('P0-b: a no-actor accept (system-mediated sync/heal shape) lands delivered, not accepted', async () => { + const h = await createHarness(); + try { + const task = h.createTask('review'); + const deliverable = h.pendingDeliverable(task.id); + + const accepted = h.bridge.acceptGroupTask(task.id); + assert.equal(accepted.groupTask.status, 'done'); + const fresh = h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id); + assert.equal(fresh.status, 'delivered', 'no actor means no owner verdict on the ledger'); + } finally { + h.cleanup(); + } +}); + +// --------------------------------------------------------------------------- +// 4: the acceptance verdict impression is owner-only +// --------------------------------------------------------------------------- + +test('P0-b: verdict impression — owner close records it for the remote author, chair close records none', async () => { + const h = await createHarness(); + try { + // Chair close on task 1: delivered rows, NO acceptance verdict impression. + const chairTask = h.createTask('review'); + h.addRemoteWorker(chairTask.id); + const chairRow = h.pendingDeliverable(chairTask.id, REMOTE_A, 'metaapp://p0b-remote-chair'); + h.wireImpressionDeps(); + await closeGroupTask(chairTask.id, { status: 'done', actor: { kind: 'chair' } }); + assert.equal( + h.verdictObservations(REMOTE_A).length, 0, + 'chair close writes no acceptance verdict impression', + ); + const chairFresh = h.groupTaskStore.listDeliverables(chairTask.id).find((item) => item.id === chairRow.id); + assert.equal(chairFresh.status, 'delivered'); + + // Owner close on task 2 (own group id — group_id is UNIQUE): accepted row + // + exactly one verdict impression. + const ownerTask = h.createTask('review', 'd'.repeat(64) + 'i0'); + h.addRemoteWorker(ownerTask.id); + const ownerRow = h.pendingDeliverable(ownerTask.id, REMOTE_A, 'metaapp://p0b-remote-owner'); + await closeGroupTask(ownerTask.id, { status: 'done', actor: { kind: 'owner' } }); + const verdicts = h.verdictObservations(REMOTE_A); + assert.equal(verdicts.length, 1, 'owner acceptance records the remote-author verdict impression'); + assert.equal( + verdicts[0].idempotencyKey, + `openteam:deliverable-verdict:${ownerTask.id}:deliverable:${ownerRow.id}:accepted`, + ); + } finally { + h.cleanup(); + } +}); + +// --------------------------------------------------------------------------- +// 5: reopen (either actor) never writes deliverable statuses +// --------------------------------------------------------------------------- + +test('P0-b: reopen (chair and owner actors) leaves deliverable rows untouched — no accepted write anywhere', async () => { + const h = await createHarness(); + try { + const task = h.createTask('review'); + const deliverable = h.pendingDeliverable(task.id); + h.groupTaskStore.updateDeliverableStatus(deliverable.id, 'delivered'); + + const reopened = await reopenGroupTask(task.id, { actor: { kind: 'chair' } }); + assert.equal(reopened.status, 'executing'); + assert.equal(reopened.statusEvents[0].actorKind, 'chair'); + let fresh = h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id); + assert.equal(fresh.status, 'delivered', 'chair reopen leaves the row delivered'); + + h.groupTaskStore.updateTaskStatus(task.id, 'review', { actor: { kind: 'chair' } }); + await reopenGroupTask(task.id, { actor: { kind: 'owner' } }); + fresh = h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id); + assert.equal(fresh.status, 'delivered', 'owner reopen leaves the row delivered'); + assert.ok( + h.groupTaskStore.listDeliverables(task.id).every((row) => row.status !== 'accepted'), + 'reopen never lands accepted', + ); + } finally { + h.cleanup(); + } +}); + +// --------------------------------------------------------------------------- +// 6: no-bridge fallback close never touches deliverables +// --------------------------------------------------------------------------- + +test('P0-b: the no-bridge fallback close leaves deliverables pending (no flip at all)', async () => { + const h = await createHarness({ withBridge: false }); + try { + const task = h.createTask('review'); + const deliverable = h.pendingDeliverable(task.id); + + const closed = await closeGroupTask(task.id, { status: 'done', actor: { kind: 'chair' } }); + assert.equal(closed.status, 'done'); + const fresh = h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id); + assert.equal(fresh.status, 'pending', 'the fallback path never flips deliverable statuses'); + } finally { + h.cleanup(); + } +}); + +// --------------------------------------------------------------------------- +// 7: heal sweep is a system catch-up — lands delivered +// --------------------------------------------------------------------------- + +test('P0-b: healAcceptedGroupTaskCards (system catch-up) lands deliverables delivered, not accepted', async () => { + const h = await createHarness(); + try { + const task = h.createTask('review'); + const deliverable = h.pendingDeliverable(task.id); + const canonical = h.bridge.ensureCanonicalTask(task.id); + // The owner closed the canonical card (acceptance happened there); the + // group task lagged behind in review. + h.orchestrationStore.recordClosure(canonical.id, { conclusion: null, by: 'owner' }); + + const report = h.bridge.healAcceptedGroupTaskCards(); + assert.deepEqual(report.healed, [{ groupTaskId: task.id, canonicalTaskId: canonical.id }]); + assert.equal(h.groupTaskStore.getTaskById(task.id).status, 'done'); + const fresh = h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id); + assert.equal(fresh.status, 'delivered', 'the system heal is not an owner verdict'); + } finally { + h.cleanup(); + } +}); diff --git a/tests/groupTaskOrchestrationBridge.test.mjs b/tests/groupTaskOrchestrationBridge.test.mjs index 9047fe466..439889982 100644 --- a/tests/groupTaskOrchestrationBridge.test.mjs +++ b/tests/groupTaskOrchestrationBridge.test.mjs @@ -134,7 +134,10 @@ test('Worker handoff, deliverable evidence, review, and owner acceptance close b h.groupTaskStore.updateTaskStatus(h.groupTask.id, 'review'); assert.equal(h.bridge.syncStatus(h.groupTask.id).status, 'review'); - const accepted = h.bridge.acceptGroupTask(h.groupTask.id); + // P0-b (task #149): explicit owner actor — this test is the owner + // acceptance lifecycle; a no-actor accept now flips deliverables to + // 'delivered' instead of 'accepted'. + const accepted = h.bridge.acceptGroupTask(h.groupTask.id, { kind: 'owner' }); assert.equal(accepted.groupTask.status, 'done'); assert.equal(accepted.canonicalTask.status, 'completed'); assert.equal(h.orchestrationStore.getStep(started.step.id).status, 'completed'); diff --git a/tests/groupTaskService.test.mjs b/tests/groupTaskService.test.mjs index 75c0881dc..f7e5b265c 100644 --- a/tests/groupTaskService.test.mjs +++ b/tests/groupTaskService.test.mjs @@ -2459,7 +2459,9 @@ test('closeGroupTask: the chair posts exactly one [STATUS:DONE]/[STATUS:CANCELLE assert.equal(announcements[0].groupId, GROUP_ID); assert.equal( announcements[0].opts.content, - '[STATUS:DONE] Task closed: accepted by the owner. Reason: goal met', + // P0-b (task #149): this harness close passes no actor, so the + // non-owner wording applies — it must not claim owner acceptance. + '[STATUS:DONE] Task closed: closed by the chair on behalf of the owner; owner acceptance pending. Reason: goal met', ); // A repeat (no-op) close of the terminal task must NOT re-announce. diff --git a/tests/ncase-chair-deliverable-presentation.test.tsx b/tests/ncase-chair-deliverable-presentation.test.tsx new file mode 100644 index 000000000..0d6ce4ebb --- /dev/null +++ b/tests/ncase-chair-deliverable-presentation.test.tsx @@ -0,0 +1,302 @@ +/** + * P0-b (task #149) — presentation regression for the chair-close deliverable + * semantics. After the acceptGroupTask actor gate, a CHAIR-closed task leaves + * its deliverable rows in 'delivered' — the detail view must render the + * delivered tier for those rows and NEVER the acceptance tier, while an owner + * accepted row keeps rendering the acceptance tier. + * + * House style: module shims + seeded row sets + react-test-renderer (the same + * approach as the ncase presentation tests). Plus static source guards that + * keep the statusKey/statusHintKey tier mapping honest in BOTH deliverable + * renderers: the accepted label may only sit behind an explicit + * `status === 'accepted'` check, and unknown statuses fall through to the + * pending label (never the accepted one) — no default branch may masquerade + * as owner acceptance. + * + * Note: tsx compiles .tsx to CJS, so the renderer module graph is imported + * dynamically inside `initRenderHarness()` AFTER the shims are installed. + */ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; + +// --------------------------------------------------------------------------- +// Shims — installed BEFORE any renderer module is imported (the dynamic +// imports inside initRenderHarness run after this module body). +// --------------------------------------------------------------------------- + +const noop = () => undefined; + +const state: { detail: Record | null } = { detail: null }; + +(globalThis as Record).IS_REACT_ACT_ENVIRONMENT = true; + +(globalThis as Record).localStorage = { + getItem: () => null, + setItem: noop, + removeItem: noop, + clear: noop, + key: () => null, + length: 0, +}; + +(globalThis as Record).document = { + visibilityState: 'hidden', // the 5s poll skips its body entirely + addEventListener: noop, + removeEventListener: noop, + createElement: () => ({ + style: {}, + setAttribute: noop, + appendChild: noop, + remove: noop, + click: noop, + href: '', + download: '', + }), + body: { appendChild: noop, removeChild: noop, contains: () => false }, + documentElement: { style: {}, setAttribute: noop }, +}; + +(globalThis as Record).window = { + electron: { + platform: 'darwin', + groupTask: { + get: async () => ({ success: true, task: state.detail }), + listMessages: async () => ({ success: true, messages: [] }), + onStatusChanged: () => () => undefined, + onCheckpointChanged: () => () => undefined, + }, + userIdentity: { + get: async () => ({ success: true, identity: { globalmetaid: 'idq1owner0000000000000000000000000000000' } }), + }, + window: { + isMaximized: async () => false, + onStateChanged: () => () => undefined, + minimize: noop, + toggleMaximize: noop, + close: noop, + showSystemMenu: noop, + on: () => () => undefined, + }, + app: { getVersion: async () => '0.0.0-test' }, + }, + setInterval: () => 0, + clearInterval: noop, + addEventListener: noop, + removeEventListener: noop, + matchMedia: () => ({ + matches: false, + addListener: noop, + removeListener: noop, + addEventListener: noop, + removeEventListener: noop, + }), + requestAnimationFrame: (cb: () => void) => setTimeout(cb, 0), + location: { href: 'http://localhost/', origin: 'http://localhost', pathname: '/' }, + navigator: (globalThis as { navigator?: unknown }).navigator, + open: noop, + isSecureContext: true, +}; + +// --------------------------------------------------------------------------- +// Deferred renderer import graph (after shims) + pinned tier labels +// --------------------------------------------------------------------------- + +type RenderDetail = (deliverableStatuses: string[]) => Promise; + +let harness: Promise | null = null; + +const initRenderHarness = (): Promise => { + if (harness) return harness; + harness = (async (): Promise => { + const React = (await import('react')).default; + const TestRendererModule = await import('react-test-renderer'); + const TestRenderer = TestRendererModule.default; + const act = TestRendererModule.act; + const { i18nService } = await import('../src/renderer/services/i18n'); + const GroupTaskDetailViewModule = await import('../src/renderer/components/groupTasks/GroupTaskDetailView'); + const GroupTaskDetailView = GroupTaskDetailViewModule.default; + + // Pin the tier labels to the real zh copy from src/renderer/services/i18n.ts + // so the assertions read against actual UI strings, not raw keys. Unknown + // keys pass through as the key itself (harmless in the serialized tree). + const STRINGS: Record = { + groupTasksDeliverableStatusPending: '待验收', + groupTasksDeliverableStatusDelivered: '已交付', + groupTasksDeliverableStatusAccepted: '已验收', + groupTasksDeliverableStatusRejected: '已拒绝', + groupTasksDeliverableStatusPendingHint: '已提交,待 owner 验收(与链上确认是两个独立维度)', + groupTasksDeliverableStatusDeliveredHint: '链上核验通过,待 owner 验收', + groupTasksDeliverableStatusAcceptedHint: '已通过 owner 验收', + groupTasksDeliverableStatusRejectedHint: '已被拒绝', + }; + (i18nService as unknown as { t: (key: string) => string }).t = (key: string) => + STRINGS[key] ?? key; + + return async (deliverableStatuses: string[]): Promise => { + state.detail = baseDetail(deliverableStatuses); + let renderer: TestRenderer.ReactTestRenderer | null = null; + await act(async () => { + renderer = TestRenderer.create( + React.createElement(GroupTaskDetailView, { taskId: TASK_ID, onBack: noop }), + ); + }); + // Let the mount-time promise chains (getTask / listMessages / identity) + // settle and their setState batches flush. + await act(async () => { + await new Promise((resolve) => setTimeout(resolve, 20)); + }); + const tree = JSON.stringify((renderer as unknown as TestRenderer.ReactTestRenderer).toJSON()); + await act(async () => { + (renderer as unknown as TestRenderer.ReactTestRenderer).unmount(); + }); + return tree; + }; + })(); + return harness; +}; + +// --------------------------------------------------------------------------- +// Seed row sets +// --------------------------------------------------------------------------- + +const TASK_ID = 7; + +const baseDetail = (deliverableStatuses: string[]): Record => ({ + id: TASK_ID, + orchestrationTaskId: null, + groupId: 'aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffff00000000i0', + title: 'P0-b presentation task', + goal: 'Ship the intro MetaApp', + acceptanceCriteria: 'Preview URL works', + status: 'done', // a CLOSED task (chair close or owner accept) + chairMetabotId: 1, + createdBy: 'user', + lastProcessedMsgId: 0, + createPinId: null, + createdAt: '2026-11-18T10:00:00.000Z', + updatedAt: '2026-11-18T11:00:00.000Z', + closedAt: '2026-11-18T11:00:00.000Z', + rating: null, + ratingComment: null, + ratedAt: null, + displayName: null, + pinned: false, + archivedAt: null, + members: [ + { + id: 1, taskId: TASK_ID, metabotId: 1, + globalmetaid: 'idq1chair00000000000000000000000000000000', + role: 'chair', joinedPinId: null, createdAt: null, name: 'Twin', status: 'done', + }, + { + id: 2, taskId: TASK_ID, metabotId: 2, + globalmetaid: 'idq1worker000000000000000000000000000000', + role: 'worker', joinedPinId: null, createdAt: null, name: 'Coder', status: 'done', + }, + ], + deliverables: deliverableStatuses.map((status, index) => ({ + id: 100 + index, + taskId: TASK_ID, + msgPinId: `pin-${index}-i0`, + authorGlobalmetaid: 'idq1worker000000000000000000000000000000', + kind: 'metaapp', + uri: `metaapp://p0b-row-${index}`, + status, + createdAt: '2026-11-18T10:30:00.000Z', + verification: null, + confirmation: 'unconfirmed', + sourceContent: null, + sourceSenderName: null, + })), + checkpoints: [], + acceptanceSummary: null, + statusEvents: [], + transitions: [], + integrityEvents: [], + supervisorSignals: [], +}); + +// --------------------------------------------------------------------------- +// Component behavior +// --------------------------------------------------------------------------- + +test('chair-closed task: delivered rows render the delivered tier, never an acceptance tier', async () => { + const renderDetail = await initRenderHarness(); + const tree = await renderDetail(['delivered', 'pending']); + assert.ok(tree.includes('已交付'), 'the delivered tier label renders for chair-closed rows'); + assert.ok(tree.includes('待验收'), 'the still-pending row keeps its own tier'); + assert.ok(!tree.includes('已验收'), 'no acceptance tier label appears anywhere for a chair close'); + assert.ok(!tree.includes('accepted ✓'), 'no accepted badge (AcceptanceSummaryCard wording) leaks in'); +}); + +test('owner-accepted task: the accepted row keeps rendering the acceptance tier', async () => { + const renderDetail = await initRenderHarness(); + const tree = await renderDetail(['accepted', 'delivered']); + assert.ok(tree.includes('已验收'), 'the acceptance tier label renders for the owner verdict'); + assert.ok(tree.includes('已交付'), 'the delivered tier still renders for on-chain verified rows'); +}); + +// --------------------------------------------------------------------------- +// Static source guards: no default branch may masquerade as owner acceptance +// --------------------------------------------------------------------------- + +const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); +const readComponent = (relative: string): string => + fs.readFileSync(path.join(projectRoot, 'src', 'renderer', 'components', 'groupTasks', relative), 'utf8'); + +for (const component of ['GroupTaskDetailView.tsx', 'OpenTeamCollabDetailView.tsx']) { + // Merge integration (task #149): P0-a nests a ledger-actor tier INSIDE the + // accepted arm of GroupTaskDetailView's statusHintKey ternary + // (status === 'accepted' ? (acceptedActorKind === 'chair' ? ByChair : owner) : …), + // so that component carries THREE accepted-key lines (status label, owner + // hint, chair hint) and the accepted check may sit up to 3 lines above the + // key. The guard stays intent-preserving: every accepted-key line must have + // an explicit `status === 'accepted'` check within its upward window — a key + // reachable from any other arm still fails. + const expectedAcceptedKeyLines: Record = { + 'GroupTaskDetailView.tsx': 3, + 'OpenTeamCollabDetailView.tsx': 2, + }; + test(`source guard ${component}: accepted label only behind an explicit accepted check; fallback is pending`, () => { + const source = readComponent(component); + const lines = source.split('\n'); + let acceptedKeyLines = 0; + for (let i = 0; i < lines.length; i += 1) { + // Prefix match on purpose: it must catch BOTH the status label + // ('groupTasksDeliverableStatusAccepted') and its hint + // ('groupTasksDeliverableStatusAcceptedHint') and, since P0-a, the + // chair tier ('groupTasksDeliverableStatusAcceptedHintByChair'). + if (lines[i].includes("'groupTasksDeliverableStatusAccepted")) { + acceptedKeyLines += 1; + // The key is a ternary CONSEQUENT; its `status === 'accepted'` + // check lives on the same line or within a few lines above + // (multi-line ternary, P0-a adds one nested actor tier). + let guarded = false; + for (let up = 1; up <= 4 && i - up >= 0; up += 1) { + if (/===\s*'accepted'/.test(lines[i - up])) { + guarded = true; + break; + } + } + assert.ok( + guarded || /===\s*'accepted'/.test(lines[i]), + `${component}: the accepted label sits behind an explicit status === 'accepted' check (line: ${lines[i].trim()})`, + ); + } + } + assert.equal( + acceptedKeyLines, + expectedAcceptedKeyLines[component], + `${component}: each accepted tier (status label + hints) referenced exactly once`, + ); + // Prefix match on purpose: catches both the status label and its hint. + const pendingFallbacks = (source.match(/'groupTasksDeliverableStatusPending/g) ?? []).length; + assert.ok( + pendingFallbacks >= 2, + `${component}: unknown statuses fall through to the pending label (statusKey + statusHintKey), never to accepted`, + ); + }); +} diff --git a/tests/ncase-presentation.test.tsx b/tests/ncase-presentation.test.tsx new file mode 100644 index 000000000..6525315e1 --- /dev/null +++ b/tests/ncase-presentation.test.tsx @@ -0,0 +1,136 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import React from 'react'; +import TestRenderer from 'react-test-renderer'; +import { i18nService } from '../src/renderer/services/i18n'; + +// P0-a (#149) 组件级测试 —— 承袭 tests/ncase-presentation.test.tsx 原件 +// (链上原文 pin://16b63f23cec3e2aa65b7ac390dd60b9e3fb5dd0c3d5c1467f9042e649d60e834i0, +// 修前工作文件 sha256 fc115127da7609cf6641b1571b3a64a76a20d0fd4e13a0da21523906139c60fa、105 行)。 +// 修前段第三例是「chair 代闭仍渲染 owner 验收文案 → 红复现」;P0-a 落地后该例翻绿: +// chair 代闭(账本 status event actor_kind=chair)必须渲染 chair 档文案, +// 且整页【不得出现】owner 验收文案(不得出现式判定)。 +// 种子行集对齐 .iso-userdata/idbots.sqlite 的 N-case 行集,并补上 P0-a 读取的 +// 落库 status event(renderer 读 GroupTaskDetail.statusEvents,camelCase)。 + +// —— 垫片:组件渲染期会读 window.electron.platform / document.visibilityState —— +(globalThis as any).window = { + electron: { + platform: 'darwin', + window: { + isMaximized: async () => false, + isFullscreen: async () => false, + isFocused: async () => true, + onStateChanged: (_cb: any) => () => {}, + onClose: (_cb: any) => () => {}, + minimize: () => {}, + toggleMaximize: () => {}, + close: () => {}, + }, + groupTask: { + onStatusChanged: (_cb: any) => () => {}, + onCheckpointChanged: (_cb: any) => () => {}, + onTurnActivityChanged: (_cb: any) => () => {}, + onOwnerReportDelivery: (_cb: any) => () => {}, + }, + userIdentity: { get: async () => ({ success: true, identity: { globalmetaid: 'ncase-owner-test' } }) }, + }, + setInterval: (_fn: any, _ms: any) => 0, // 不真排程:轮询与渲染语义无关,防 act 内无限重排 + setTimeout: (fn: any, ms: any) => globalThis.setTimeout(fn, ms), + clearInterval: (id: any) => globalThis.clearInterval(id), + clearTimeout: (id: any) => globalThis.clearTimeout(id), + addEventListener: () => {}, + removeEventListener: () => {}, + requestAnimationFrame: (fn: any) => globalThis.setTimeout(fn, 0), + location: { reload: () => {} }, + visibilityState: 'visible', +}; +(globalThis as any).document = { visibilityState: 'visible', addEventListener: () => {}, removeEventListener: () => {} }; +(globalThis as any).matchMedia = (globalThis as any).matchMedia || (() => ({ matches: false, addEventListener: () => {}, removeEventListener: () => {} })); + +// —— 种子行(对齐 .iso-userdata/idbots.sqlite 的 N-case 行集)—— +const mkDeliverable = (id: number, taskId: number, uri: string, status: string) => ({ + id, taskId, msgPinId: null, authorGlobalmetaid: 'idq1nqworker0000000000000000000000000', + kind: 'file', uri, status, confirmation: 'confirmed', created_at: '2026-11-13', verification: null, content_hash: null, +}); +const mkStatusEvent = (id: number, taskId: number, fromStatus: string, toStatus: string, actorKind: string, actorName: string | null, createdAt: string) => ({ + id, taskId, fromStatus, toStatus, actorKind, actorGlobalMetaId: null, actorName, createdAt, +}); +const baseTask = { + orchestrationTaskId: null, groupId: null, acceptanceCriteria: null, chairMetabotId: 1, + createdBy: 'user', lastProcessedMsgId: 0, lastDrivenAt: null, createPinId: null, + displayName: null, pinned: false, archivedAt: null, sourceSessionId: null, + dispatchPausedAt: null, mode: 'task', members: [], rating: null, ratingComment: null, ratedAt: null, +}; +const task1: any = { ...baseTask, id: 1, title: 'N-case 验收语义测试', goal: 'g', status: 'review', + deliverables: [mkDeliverable(1, 1, 'metafile://ncase-n1-delivered', 'delivered'), + mkDeliverable(2, 1, 'metafile://ncase-n2-accepted', 'accepted')], + statusEvents: [mkStatusEvent(11, 1, 'review', 'done', 'owner', 'Owner', '2026-11-13 13:50:00')] }; +const task2: any = { ...baseTask, id: 2, title: 'N5 chair-RPC 关单测试', goal: 'g', status: 'done', + closedAt: '2026-11-13 13:55:05', + deliverables: [mkDeliverable(3, 2, 'metafile://ncase-n5-pending', 'accepted')], + // N5 实测口径:chair 代闭落库 status event actor_kind='chair'(actor_globalmetaid 空串)。 + statusEvents: [mkStatusEvent(21, 2, 'review', 'done', 'chair', null, '2026-11-13 13:55:05')] }; + +let inited: ((taskId: number) => Promise) | null = null; +async function init(): Promise<(taskId: number) => Promise> { + if (inited) return inited; + const { groupTaskService } = await import('../src/renderer/services/groupTaskService'); + const overrides: Record = { + getTask: async (id: number) => (id === 2 ? task2 : task1), + listMessages: async () => ({ messages: [], hasMore: false, page: 1, total: 0 }), + list: async () => [task1, task2], + }; + Object.assign(groupTaskService as any, overrides); + const mod = await import('../src/renderer/components/groupTasks/GroupTaskDetailView'); + const GroupTaskDetailView = mod.default; + inited = async (taskId: number): Promise => { + let tr: any; + await TestRenderer.act(async () => { tr = TestRenderer.create(React.createElement(GroupTaskDetailView, { taskId, onBack: () => {} })); }); + await TestRenderer.act(async () => { await new Promise(r => setTimeout(r, 250)); }); + const json = tr.toJSON ? tr.toJSON() : tr; + return JSON.stringify(json); + }; + return inited; +} + +const OWNER_HINT = i18nService.t('groupTasksDeliverableStatusAcceptedHint'); +const CHAIR_HINT = i18nService.t('groupTasksDeliverableStatusAcceptedHintByChair'); +const ACCEPTED_LABEL = i18nService.t('groupTasksDeliverableStatusAccepted'); +const DELIVERED_HINT = i18nService.t('groupTasksDeliverableStatusDeliveredHint'); + +test('P0-a 前置: chair 档 i18n key 已落双语词典且 chair 文案不含「owner 验收」字样', async () => { + assert.ok(CHAIR_HINT && CHAIR_HINT !== 'groupTasksDeliverableStatusAcceptedHintByChair', + 'chair 档 key 未落词典(返回了 key 本身)'); + // 不得出现式判定:chair 档文案自身不得含「owner 验收」子串(中英两档各自守)。 + assert.ok(!CHAIR_HINT.includes('owner 验收'), `chair 文案含禁字样「owner 验收」: ${CHAIR_HINT}`); + assert.ok(!CHAIR_HINT.includes('Accepted by the owner'), `chair 文案含禁句「Accepted by the owner」: ${CHAIR_HINT}`); +}); + +test('N2: owner 验收(actor_kind=owner)渲染 owner 验收文案(恰好一次)', async () => { + const text = await (await init())(1); + assert.ok(text.includes(OWNER_HINT), 'owner 验收的 owner 档文案缺失'); + const occurrences = text.split(OWNER_HINT).length - 1; + assert.equal(occurrences, 1, `owner 验收文案应恰好 1 次(仅 accepted 行),实为 ${occurrences}`); + assert.ok(text.includes(ACCEPTED_LABEL), 'accepted 状态标签缺失'); +}); + +test('N1: delivered deliverable 不渲染 owner 验收文案', async () => { + const text = await (await init())(1); + const deliveredOk = text.includes(DELIVERED_HINT) || text.includes('awaiting owner acceptance'); + assert.ok(deliveredOk, 'delivered 行渲染缺失'); + const beforeDelivered = text.split(DELIVERED_HINT)[0]; + assert.ok(!beforeDelivered.includes(OWNER_HINT), 'delivered 段不应携带 owner 验收文案'); +}); + +test('N5 修后: chair 代闭(status event actor_kind=chair)渲染 chair 档文案且整页不含 owner 验收文案', async () => { + const text = await (await init())(2); + assert.ok(text.includes(CHAIR_HINT), 'chair 代闭未渲染 chair 档文案'); + // 不得出现式判定:chair 代闭的整页渲染不得出现 owner 验收文案。 + assert.ok(!text.includes(OWNER_HINT), `chair 代闭页面不得出现 owner 验收文案,实渲染了 ${text.split(OWNER_HINT).length - 1} 次`); + // 数据源判定(渲染证据):落库 status event 进了状态史区块(actorName 为空时回显 actorKind='chair'), + // 组件手里唯一的 chair 信号就是这个事件——分档只可能来自它,而非 session 状态或 UI 现场推断。 + // 注:TestRenderer JSON 里 fromStatus/→/toStatus 是三个分离文本节点,箭头按带引号片段匹配。 + assert.ok(text.includes('" → "'), 'task2 的落库 close 事件未进状态史渲染'); + assert.ok(text.includes('· chair ·'), 'chair actor 未能从落库 status event 渲染出来'); +}); diff --git a/tests/openTeamImpressionService.test.mjs b/tests/openTeamImpressionService.test.mjs index 63b63f241..a660de341 100644 --- a/tests/openTeamImpressionService.test.mjs +++ b/tests/openTeamImpressionService.test.mjs @@ -683,7 +683,10 @@ test('hook bridge acceptGroupTask: pending deliverables accepted; verdict impres h.wireDeps(); const appendCalls = h.spyOnAppend(); - const { groupTask } = bridge.acceptGroupTask(task.id); + // P0-b (task #149): explicit owner actor — verdict impressions are the + // OWNER's acceptance record; a no-actor accept no longer flips rows to + // 'accepted' nor writes impressions. + const { groupTask } = bridge.acceptGroupTask(task.id, { kind: 'owner' }); assert.equal(groupTask.status, 'done'); const deliverables = h.groupTaskStore.listDeliverables(task.id); assert.ok(deliverables.every((deliverable) => deliverable.status === 'accepted'), 'all pending deliverables accepted'); @@ -749,7 +752,9 @@ test('hook bridge acceptGroupTask: a kicked remote author\'s swept-up deliverabl h.wireDeps(); const appendCalls = h.spyOnAppend(); - const { groupTask } = bridge.acceptGroupTask(task.id); + // P0-b (task #149): explicit owner actor — the bulk-accept sweep below is + // an owner acceptance; a no-actor accept now lands 'delivered' instead. + const { groupTask } = bridge.acceptGroupTask(task.id, { kind: 'owner' }); assert.equal(groupTask.status, 'done'); assert.equal( h.groupTaskStore.listDeliverables(task.id).find((item) => item.id === deliverable.id)?.status,