Merge branch 'codex/inplace-slice-editing' into codex/ise-ux-03

This commit is contained in:
d-robotics 2026-10-13 20:14:32 +05:30
commit 58671470ea
19 changed files with 944 additions and 91 deletions

View File

@ -1,6 +1,6 @@
# 批 0-1:E 模式入口稳定化(横幅浮层化 + 单切片禁 E)
Status: ready-for-agent
Status: resolved
Type: task
Blocked by: —
Batch: 0 · stabilization(独立提交,完成后用户在 5174 重测)
@ -34,3 +34,11 @@ Batch: 0 · stabilization(独立提交,完成后用户在 5174 重测)
## 参考
spec `批 0` 第 1、4 条;调查报告 I2a/I2b。
## Resolution
- 分支 `codex/ise-ux-01`(`3d25fc97` claim → `51f15625` 实现),合入集成分支 merge commit `94231d55`。
- I2a 采用票面允许的等价方案:**恒定占位槽**(annotate 相恒挂 `slice-edit-banner-slot`,横幅 `absolute` 浮于槽内)——轨道上方的 seek 滑杆/返工意见条是活控件,自由浮层会盖住它们;进出模式按构造零位移。代价:annotate 相多 ~36px 恒定占位行(批 1 随模式整体移除)。
- I2b 三层拦截:`annotationShortcut` 新增 `sliceEditEntry` 选项(E → `slice-edit-unavailable`)+ `enterSliceEditMode` 在副作用前拦 `slices.length < 2` + 模式内合并到单切片自动退出。提示「仅一个切片,无可调边界」2.5s 自消。`sliceEditShortcut` 无需改(单切片下模式不可达)。
- 验证:tsc exit 0;前端 730/716/14 → **732/718/14**(+2 恰为两条新测试,均过);失败名单 pre/post 逐名一致;merger 独立复跑两测试文件,其中对 AnnotationOperations.tsx 的 `/requireSliceCompletion: true/` 静态守护失败经基线 1d58d7aa A/B 确认为既有债,非本票引入。改动文件 prettier 全 clean。
- 人工验收(5173/5174 重播种后)待用户:① 进/出 E 轨道像素级零位移;② 单切片按 E 出提示不进模式。

View File

@ -1,6 +1,6 @@
# 批 0-2:导航连续性(J/K 跨片自动开编辑器 + 弃用片动作栏保留)
Status: ready-for-agent
Status: resolved
Type: task
Blocked by: —
Batch: 0 · stabilization(独立提交,完成后用户在 5174 重测)
@ -31,3 +31,12 @@ Batch: 0 · stabilization(独立提交,完成后用户在 5174 重测)
## 参考
spec `批 0` 第 2、3 条;调查报告 I1/I4。
## Resolution
- 分支 `codex/ise-ux-02`(`cbcac718` claim → `6ffdcb6e` 实现 → `e8cf0216` 合集成分支 tip),merger 合入 merge commit `9b4087c9`。
- **I1**:新纯函数 `reworkLocatePlan`(rework-emphasis 家族,+ReworkLocatePlan 类型);`jumpReworkProblem` 与 `locateReworkOpinion` 共用同一决策与执行器。跨片跳锚定动作意见 → 选片后自动开编辑器 + 动作栏滚动定位;同片 J/K 仍只 seek(测试钉死);目标片弃用或停泊草稿不覆盖(草稿安全)。
- **偏差(已核准)**:跨片**点击**路径原先也不开编辑器(票面描述与代码实情有出入),已一并补齐,「与点击路径一致」双向成立。
- **I4**:去 `!selectedDiscarded` 卸载门槛;弃用片动作栏保留挂载,经新纯函数 `archivedAnnotationsForSlice` 只读展示归档动作(disabled、无编辑入口、意见红标保留);标注员与 QC 共用同栏一并修复。
- 验证:tsc 0 错;前端 730/716/14 → 735/721/14 → 合并后 737/723/14,失败名集三次逐字节一致;merger 独立复跑 rework-emphasis 33/33、annotation-workbench 22/22 全绿。
- 人工验收待用户(重播种后):J/K 跨片锚定意见自动开编辑器;A:S5 / B:S3 弃用片动作栏只读保留。

View File

@ -1,6 +1,6 @@
# 批 2-1:退回基线契约(服务端)+ ADR 0008
Status: ready-for-agent
Status: resolved
Type: task
Blocked by: —
Batch: 2 · 质检(可与批 0/批 1 并行开发;10 依赖本票)
@ -31,3 +31,9 @@ R1-Q8(用户改推荐:彻底不显示):质检再退回时,新基线 =
## 参考
spec §2 R1-Q8/R2-Q7/R3-Q4、§3 批 2 第 4 条、§4 seam ②;`internal/api/` rework 相关 handler 与既有表驱动测试。
## Comments
- 2026-10-13(merger):合入集成分支 merge commit `149ee297`(与 02 前后脚,零冲突);merger 独立复跑 `go test ./internal/api/ -run 'ReworkBaseline|AcceptanceSourceOpinions|ReworkReturnBaseline'` 全绿。证据见下方实施代理注记。Status → resolved。
- 2026-10-13(实施代理):已实现,commit `285f895d`(代码+测试+ADR 0008 同批),claim commit `22fe3e58`。构造点:`internal/api/review_decision_plan.go` `planQualityReviewDecision` → 纯函数 `reworkBaselineProblems`(`internal/api/rework_baseline_contract.go`);读收窄:`handleReworkBaseline`(任意 `?round=`)与 `/source-opinions` 基线投影共用 `visibleReworkBaselineProblems`(按 `ReviewRound == N` 的 `AnnotationReviewRecord.Confirmations` 剔除已解决,冻结记录不动)。表驱动:`TestReworkBaselineProblemsCarriesUnresolvedOnly` 6 例 + HTTP 多轮 `TestReworkReturnBaselineUnresolvedOnlyAcrossRounds` + 兜底 `TestReworkBaselineLegacyRoundsDefaultUnresolved`,全绿;`TestAcceptanceSourceOpinionsProjection` 断言随契约更新(已解决 src-ts 不再投影,核对结论仍在)。`go test ./...` 前后失败名集合 70 条 byte-identical;`gofmt -l` 本票文件干净(存量 12 文件债务未动)。给票 10:`rework-baseline` 响应字段不变、只收窄 `problems`(未解决在前同 ID、`\n【质检备注】…` 追加块),无需改 API 客户端。Status 保持 claimed,待批间验收。

View File

@ -0,0 +1,30 @@
# ADR 0008: 退回基线只含未解决意见
日期:2026-10-13
状态:已接受(spec `slice-edit-ux-rework` R1-Q8 / R2-Q7 / R3-Q4 用户拍板)
## 背景
复审(退回后的再核对)要逐条判定上一轮退回意见的状态:`1` 已解决 / `2` 仍有问题(必填现场说明)。旧契约下再退回的新基线只冻结核对当轮新写的意见:判"已解决"的旧意见下一轮不再出现(轨迹只在旧基线记录里),但判"仍有问题"的旧意见要求复审员**重写一条新意见**来表达——同一条问题每轮换一个条目 ID,标注员侧 J/K 逐条跳的数目与顺序随轮次漂移;而复审页对已解决项的呈现(折叠?带勾?)始终是界面噪音:标注员要处理的是"还没改好的",不是"已经改好的"。
## 决策
1. **再退回的新基线 = 未解决旧意见 + 本轮新增**(R1-Q8)。构造位置:`internal/api/review_decision_plan.go` 的 `planQualityReviewDecision`(rework 退回路径),纯函数 `reworkBaselineProblems`(`internal/api/rework_baseline_contract.go`)负责合成:未解决旧意见在前(同条目原样延续),本轮新写意见在后。判"已解决"的旧意见**不进新基线**。
2. **"仍有问题"保持同一条目**(R2-Q7):复审备注以 `\n【质检备注】…` 并入原意见文本,条目 ID 不变、基线条目数不多跳;多轮反复判"仍有问题"则备注块逐轮累积,历史链路在同一条目内可读。
3. **任何基线查询接口都不返回已解决意见**(彻底不显示,不折叠):`GET /api/human-items/{id}/rework-baseline`(任意 `?round=`,标注员与复审两侧消费)与终审意见来源投影(`/source-opinions` 的 baselines 列表)统一走 `visibleReworkBaselineProblems` 收窄视图——按"核对过该轮基线"的正式审查记录(`AnnotationReviewRecord.Confirmations`,`ReviewRound == N`)剔除已解决项。**冻结基线记录本身一字不动**(B02 不变)。
4. **完整轨迹只保留在服务端正式审查记录**:冻结的各轮基线记录(含已解决意见原文)+ 正式审查记录的核对结论(谁、哪轮、判了什么、说明是什么)永久可查,作为唯一审计面。
5. **兼容兜底**:旧多轮数据/旧客户端没有核对结论字段(意见状态缺失)时按**未解决**处理——旧意见继续进新基线、继续在查询接口返回。方向刻意保守:宁可多延续一条意见,也不静默丢意见。缺失旧基线(更早期数据)或当前轮无旧基线(首标退回)时行为与旧契约一致(仅本轮新增)。
6. **消费接口字段不变**:标注员侧 `rework-baseline` 响应结构照旧,只收窄 `problems` 内容;前端适配(红灰投影、J/K)在票 10 处理,本决策纯服务端先行。
## 后果
- 界面不可追溯已解决项:标注员与复审界面上已解决意见消失(条目数只减不增);追溯只能走服务端正式审查记录(复核/审计场景),产品上接受。
- `TestAcceptanceSourceOpinionsProjection` 的断言随本决策更新:投影基线不再含已判解决的 `src-ts`(改断言只余未确认的 `src-open`),核对结论仍完整投影(reviews 列表)。
- 旧客户端窗口期(未送核对结论的复审界面)再退回会把全部旧意见按未解决延续,可能出现与手写新意见并存的同目标冗余条目;票 10 的判定键(`1`/`2`)上线后该窗口关闭。
- 备注并入改变冻结基线中的意见文本(`\n【质检备注】` 前缀是机器可识别的追加块);前端按换行渲染即可,无需解析语义。
## 替代方案(弃用)
- **折叠显示已解决项**:保留条目、界面折叠。弃用——标注员工作面只关心未完成项,折叠行仍是噪音,J/K 仍要跨过它们;"彻底不显示"是用户明确改判的推荐(R1-Q8)。
- **冻结基线记录上打已解决标记、前端过滤**:要求改写 B02 冻结记录(不可变契约)或让所有消费端各自实现过滤,旧客户端无法过滤,且读写两端要同步部署。弃用——收窄收敛在服务端查询视图一处。
- **复审重写意见表达"仍有问题"**(旧事实行为):每轮产生新条目 ID,条目数与 J/K 跳转随轮次漂移,R2-Q7 明确否决。

View File

@ -48,31 +48,34 @@ func (s *server) handleAcceptanceSourceOpinions(w http.ResponseWriter, r *http.R
"baselines": []map[string]any{},
"reviews": []map[string]any{},
}
// 每轮退回基线(原正式意见 + 说明)。
// 质检正式判定(含 D7 核对结论冻结)——先加载:基线投影要用它收窄。
var reviews []domain.AnnotationReviewRecord
if source.LegacyTaskID != "" {
list, re := s.store.ListAnnotationReviews(r.Context(), source.OrganizationID, source.LegacyTaskID)
if re == nil {
reviews = list
projection := make([]map[string]any, 0, len(reviews))
for _, review := range reviews {
projection = append(projection, map[string]any{
"round": review.ReviewRound, "decision": string(review.Decision), "reviewerUserId": review.ReviewerUserID,
"comment": review.Comment, "confirmations": review.Confirmations, "createdAt": review.CreatedAt,
})
}
entry["reviews"] = projection
}
}
// 每轮退回基线(原正式意见 + 说明)。R1-Q8(ADR 0008):已判解决的
// 历史意见在任何基线查询接口都不再返回;解决轨迹走上方 reviews 投影。
for round := 1; round <= source.ReviewRound; round++ {
baseline, be := s.store.GetReworkBaseline(r.Context(), store.ReworkBaselineID(source.ID, round))
if be != nil || baseline == nil {
continue
}
entry["baselines"] = append(entry["baselines"].([]map[string]any), map[string]any{
"round": baseline.Round, "problems": baseline.Problems, "comment": baseline.Comment,
"round": baseline.Round, "problems": visibleReworkBaselineProblems(baseline, reviews), "comment": baseline.Comment,
"reviewerOperationId": baseline.ReviewOperationID, "createdAt": baseline.CreatedAt,
})
}
// 质检正式判定(含 D7 核对结论冻结)。
if source.LegacyTaskID != "" {
reviews, re := s.store.ListAnnotationReviews(r.Context(), source.OrganizationID, source.LegacyTaskID)
if re == nil {
list := make([]map[string]any, 0, len(reviews))
for _, review := range reviews {
list = append(list, map[string]any{
"round": review.ReviewRound, "decision": string(review.Decision), "reviewerUserId": review.ReviewerUserID,
"comment": review.Comment, "confirmations": review.Confirmations, "createdAt": review.CreatedAt,
})
}
entry["reviews"] = list
}
}
opinions = append(opinions, entry)
}
renderJSON(w, http.StatusOK, map[string]any{"opinions": opinions})

View File

@ -64,11 +64,12 @@ func acceptanceProjectionFixture(t *testing.T) (dataStore store.Store, handler h
t.Fatal("aggregate acceptance item missing")
}
t.Logf("aggregate: plugin=%s scope=%s supplier=%q task=%q stage=%s", aggregate.PluginID, aggregate.ProcessingScope, aggregate.SupplierID, aggregate.LegacyTaskID, aggregate.CurrentStageID)
// 投影数据:一轮退回基线(含时间点意见)+ 一条质检正式判定(含 D7 冻结确认)。
// 投影数据:一轮退回基线(含时间点意见 + 一条未确认的遗留意见)+ 一条质检
// 正式判定(含 D7 冻结确认;src-ts 已判解决)。
if err := dataStore.UpsertReworkBaseline(ctx, domain.ReworkBaselineRecord{
ID: store.ReworkBaselineID(source.ID, 1), OrganizationID: source.OrganizationID, ProjectID: source.ProjectID,
ItemID: source.ID, BatchID: source.BatchID, Round: 1, StageID: domain.FanyuV58StageAnnotationCombined,
Problems: []domain.ReviewProblem{{ID: "src-ts", Scope: "timestamp", SliceID: "slice", AtSeconds: 8, Start: 8, End: 8, Text: "来源时间点问题"}},
Problems: []domain.ReviewProblem{{ID: "src-ts", Scope: "timestamp", SliceID: "slice", AtSeconds: 8, Start: 8, End: 8, Text: "来源时间点问题"}, {ID: "src-open", Scope: "slice", SliceID: "slice", Start: 0, End: 20, Text: "来源遗留问题"}},
Comment: "第一轮退回说明", CreatedAt: now,
}); err != nil {
t.Fatal(err)
@ -164,8 +165,10 @@ func TestAcceptanceSourceOpinionsProjection(t *testing.T) {
t.Fatalf("one source expected: %s", w.Body.String())
}
opinion := body.Opinions[0]
if opinion.ItemKey != "clip-v58b" || len(opinion.Baselines) != 1 || len(opinion.Baselines[0].Problems) != 1 || opinion.Baselines[0].Problems[0].Scope != "timestamp" {
t.Fatalf("baseline projection: %+v", opinion)
// R1-Q8(ADR 0008):基线投影不返回已判解决的 src-ts,只余未确认的 src-open;
// 解决轨迹保留在 reviews 投影的冻结核对结论中(服务端正式审查记录)。
if opinion.ItemKey != "clip-v58b" || len(opinion.Baselines) != 1 || len(opinion.Baselines[0].Problems) != 1 || opinion.Baselines[0].Problems[0].ID != "src-open" {
t.Fatalf("baseline projection must hide resolved opinions: %+v", opinion)
}
if len(opinion.Reviews) != 1 || opinion.Reviews[0].ReviewerUserID != quality.ID || opinion.Reviews[0].Round != 1 {
t.Fatalf("review projection (who/which round): %+v", opinion.Reviews)

View File

@ -40,11 +40,26 @@ func (s *server) planQualityReviewDecision(w http.ResponseWriter, r *http.Reques
renderError(w, http.StatusInternalServerError, e)
return
}
// R1-Q8(ADR 0008):再退回基线 = 未解决旧意见(同条目延续,"仍有问题"
// 备注并入原文本 R2-Q7)+ 本轮新增。已解决旧意见不进新基线——完整轨迹
// 保留在冻结的旧基线记录与正式审查记录。缺旧基线(首标退回)或缺失
// 核对结论(旧数据/旧客户端)按未解决兜底延续。
var priorProblems []domain.ReviewProblem
if item.ReviewRound > 0 {
prior, e := s.store.GetReworkBaseline(r.Context(), store.ReworkBaselineID(item.ID, item.ReviewRound))
if e != nil {
renderError(w, http.StatusInternalServerError, e)
return
}
if prior != nil {
priorProblems = prior.Problems
}
}
baseline := domain.ReworkBaselineRecord{
ID: store.ReworkBaselineID(item.ID, item.ReviewRound+1), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID,
ItemID: item.ID, BatchID: item.BatchID, Round: item.ReviewRound + 1, StageID: domain.FanyuV58StageAnnotationCombined,
RejectID: op.ID + ":reject", ReviewOperationID: op.ID, ReviewedRevision: task.CurrentRevision, ResultVersion: op.ResultVersion,
Problems: op.Draft.Problems, Comment: strings.TrimSpace(payload.Comment), CreatedAt: now,
Problems: reworkBaselineProblems(priorProblems, op.Draft.Confirmations, op.Draft.Problems), Comment: strings.TrimSpace(payload.Comment), CreatedAt: now,
}
for _, e := range baselineEvidence {
baseline.Slices = append(baseline.Slices, e.slices...)

View File

@ -0,0 +1,104 @@
package api
import (
"context"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"strings"
)
// reworkQCNotePrefix 是复审"仍有问题"备注并入原意见文本的前缀(R2-Q7):
// 标注员侧一条意见 = 原文本 + 追加备注块,条目 ID 不变、基线条目数不多跳。
const reworkQCNotePrefix = "【质检备注】"
// reworkBaselineProblems 构造再退回时的新基线意见集(R1-Q8,ADR 0008):
//
// 新基线 = 未解决旧意见(在前,同条目 ID 原样延续) + 本轮新写意见(在后)。
//
// - 判"已解决"的旧意见不进新基线:完整轨迹只保留在冻结的旧基线记录与
// 正式审查记录(AnnotationReviewRecord.Confirmations),界面永不显示;
// - 判"仍有问题"的旧意见保持同一条目(R2-Q7):备注以
// "\n【质检备注】…" 并入原文本,多轮判定逐块累积,不产生新条目 ID;
// - 兜底:没有核对结论的旧意见(旧多轮数据缺失意见状态、或旧客户端未送
// 核对结论)按"未解决"处理,继续进基线——宁可延续也不丢意见。
//
// 输入 confirmations 已由 canonicalReviewConfirmations 校验只引用旧基线意见;
// 这里对未校验来源(如直接复用)同样安全:未知 ID 的结论自然落空。
func reworkBaselineProblems(prior []domain.ReviewProblem, confirmations []domain.ReviewConfirmation, fresh []domain.ReviewProblem) []domain.ReviewProblem {
verdicts := make(map[string]domain.ReviewConfirmation, len(confirmations))
for _, c := range confirmations {
verdicts[c.OpinionID] = c
}
out := make([]domain.ReviewProblem, 0, len(prior)+len(fresh))
for _, p := range prior {
c, confirmed := verdicts[p.ID]
if confirmed && c.Resolved {
continue // 已解决:不进新基线(R1-Q8)。
}
if confirmed && !c.Resolved {
if note := strings.TrimSpace(c.Note); note != "" {
p.Text = p.Text + "\n" + reworkQCNotePrefix + note
}
}
out = append(out, p)
}
out = append(out, fresh...)
return out
}
// resolvedReworkOpinionIDs 汇总"核对过第 N 轮基线"的正式审查记录中判已解决的
// 意见 ID(ReviewRound == N 的 AnnotationReviewRecord.Confirmations)。没有对应
// 审查记录、或意见没有核对结论 → 不在集合内 = 未解决(兜底语义,ADR 0008)。
func resolvedReworkOpinionIDs(reviews []domain.AnnotationReviewRecord, round int) map[string]bool {
resolved := map[string]bool{}
for _, review := range reviews {
if review.ReviewRound != round {
continue
}
for _, c := range review.Confirmations {
if c.Resolved {
resolved[strings.TrimSpace(c.OpinionID)] = true
}
}
}
return resolved
}
// visibleReworkBaselineProblems 是所有基线查询接口的统一收窄视图(R1-Q8:
// 已解决意见彻底不返回,不折叠)。冻结记录本身不动,返回新切片。
func visibleReworkBaselineProblems(baseline *domain.ReworkBaselineRecord, reviews []domain.AnnotationReviewRecord) []domain.ReviewProblem {
if baseline == nil {
return nil
}
resolved := resolvedReworkOpinionIDs(reviews, baseline.Round)
if len(resolved) == 0 {
return baseline.Problems
}
out := make([]domain.ReviewProblem, 0, len(baseline.Problems))
for _, p := range baseline.Problems {
if resolved[p.ID] {
continue
}
out = append(out, p)
}
return out
}
// visibleReworkBaseline 读取第 round 轮冻结基线并应用 R1-Q8 收窄视图。
// 消费接口字段不变(只收窄 problems 内容);缺基线返回 nil 原样降级。
func (s *server) visibleReworkBaseline(ctx context.Context, item domain.HumanItemRecord, round int) (*domain.ReworkBaselineRecord, error) {
baseline, e := s.store.GetReworkBaseline(ctx, store.ReworkBaselineID(item.ID, round))
if e != nil || baseline == nil {
return baseline, e
}
if item.LegacyTaskID == "" {
return baseline, nil
}
reviews, e := s.store.ListAnnotationReviews(ctx, item.OrganizationID, item.LegacyTaskID)
if e != nil {
return nil, e
}
visible := *baseline
visible.Problems = visibleReworkBaselineProblems(baseline, reviews)
return &visible, nil
}

View File

@ -0,0 +1,306 @@
package api
import (
"droboticflow/internal/domain"
"droboticflow/internal/store"
"encoding/json"
"net/http"
"strings"
"testing"
)
// ADR 0008(spec slice-edit-ux-rework §2 R1-Q8/R2-Q7,seam ②):
// 再退回生成的新意见基线 = 未解决旧意见 + 本轮新增;已解决意见不进基线;
// "仍有问题"的意见保持同一条目(备注并入原文本,不产生新条目 ID);
// 旧多轮数据缺失核对结论(意见状态)时按"未解决"兜底。
func TestReworkBaselineProblemsCarriesUnresolvedOnly(t *testing.T) {
problem := func(id, text string) domain.ReviewProblem {
return domain.ReviewProblem{ID: id, Scope: "slice", SliceID: "left", Text: text}
}
confirmation := func(id string, resolved bool, note string) domain.ReviewConfirmation {
return domain.ReviewConfirmation{OpinionID: id, Resolved: resolved, Note: note}
}
cases := []struct {
name string
prior []domain.ReviewProblem
confirmations []domain.ReviewConfirmation
fresh []domain.ReviewProblem
wantIDs []string
wantTexts map[string]string
}{
{
name: "首轮退回:无旧基线,仅本轮新增",
fresh: []domain.ReviewProblem{problem("op-a", "甲"), problem("op-b", "乙"), problem("op-c", "丙")},
wantIDs: []string{"op-a", "op-b", "op-c"},
wantTexts: map[string]string{"op-a": "甲", "op-b": "乙", "op-c": "丙"},
},
{
name: "再退回:已解决不进基线,未解决在前新增在后",
prior: []domain.ReviewProblem{problem("op-a", "甲"), problem("op-b", "乙"), problem("op-c", "丙")},
confirmations: []domain.ReviewConfirmation{confirmation("op-a", true, "已核对"), confirmation("op-b", true, ""), confirmation("op-c", false, "改后区间仍多 2 秒")},
fresh: []domain.ReviewProblem{problem("op-d", "丁"), problem("op-e", "戊")},
wantIDs: []string{"op-c", "op-d", "op-e"},
wantTexts: map[string]string{
"op-c": "丙\n【质检备注】改后区间仍多 2 秒",
"op-d": "丁",
"op-e": "戊",
},
},
{
name: "兜底:缺失核对结论按未解决延续(旧多轮数据)",
prior: []domain.ReviewProblem{problem("op-a", "甲"), problem("op-b", "乙")},
fresh: []domain.ReviewProblem{problem("op-c", "丙")},
wantIDs: []string{"op-a", "op-b", "op-c"},
wantTexts: map[string]string{"op-a": "甲", "op-b": "乙", "op-c": "丙"},
},
{
name: "部分核对:只确认了一条已解决,其余延续",
prior: []domain.ReviewProblem{problem("op-a", "甲"), problem("op-b", "乙")},
confirmations: []domain.ReviewConfirmation{confirmation("op-a", true, "已核对")},
fresh: []domain.ReviewProblem{problem("op-c", "丙")},
wantIDs: []string{"op-b", "op-c"},
wantTexts: map[string]string{"op-b": "乙", "op-c": "丙"},
},
{
name: "仍有问题无备注:原文不变仍延续(防御分支)",
prior: []domain.ReviewProblem{problem("op-a", "甲")},
confirmations: []domain.ReviewConfirmation{confirmation("op-a", false, "")},
fresh: nil,
wantIDs: []string{"op-a"},
wantTexts: map[string]string{"op-a": "甲"},
},
{
name: "多轮备注累积:旧备注块保留,新备注块追加",
prior: []domain.ReviewProblem{problem("op-c", "丙\n【质检备注】第一轮仍多 2 秒")},
confirmations: []domain.ReviewConfirmation{
confirmation("op-c", false, " 第二轮仍多 1 秒 "),
},
fresh: []domain.ReviewProblem{},
wantIDs: []string{"op-c"},
wantTexts: map[string]string{"op-c": "丙\n【质检备注】第一轮仍多 2 秒\n【质检备注】第二轮仍多 1 秒"},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
got := reworkBaselineProblems(tc.prior, tc.confirmations, tc.fresh)
if len(got) != len(tc.wantIDs) {
t.Fatalf("条目数 = %d, want %d (%+v)", len(got), len(tc.wantIDs), got)
}
for i, id := range tc.wantIDs {
if got[i].ID != id {
t.Fatalf("第 %d 条 ID = %q, want %q(条目 ID 不得漂移)", i, got[i].ID, id)
}
if got[i].Text != tc.wantTexts[id] {
t.Fatalf("意见 %q 文本 = %q, want %q", id, got[i].Text, tc.wantTexts[id])
}
}
})
}
}
// —— HTTP seam:退回路径端到端(rework 退回路径构造 + 基线查询收窄)——
// reworkRejectRound 走真实退回路径:开审查会话 → 存意见草稿(model 2,含核对
// 结论)→ 提交退回决定。正式效果落库后返回。
func reworkRejectRound(t *testing.T, f combinedDraftFixture, operationID string, problems, confirmations []map[string]any) {
t.Helper()
version, headers := openReviewDraftSession(t, f)
draftVersion := 0
if problems != nil || confirmations != nil {
payload := map[string]any{"version": 0, "resultVersion": version, "operationId": operationID + "-draft",
"modelVersion": 2, "problems": problems}
if confirmations != nil {
payload["confirmations"] = confirmations
}
w := reviewSessionRequest(f, http.MethodPut, "/api/human-items/"+f.item.ID+"/review-draft", f.reviewer, payload, headers)
if w.Code != 200 {
t.Fatalf("draft save: %d %s", w.Code, w.Body.String())
}
draftVersion = readReviewDraft(t, f, "/api/human-items/"+f.item.ID+"/review-draft").Version
}
input := map[string]any{"stage": "quality", "decision": "rejected", "reasonCodes": []string{"manual_review_reject"},
"comment": "退回基线契约验证", "problemSliceIds": []string{"left"}, "operationId": operationID,
"draftVersion": draftVersion, "resultVersion": version}
w := reviewSessionRequest(f, http.MethodPost, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/reviews", f.reviewer, input, headers)
if w.Code != http.StatusCreated && w.Code != http.StatusAccepted {
t.Fatalf("rejection %s: %d %s", operationID, w.Code, w.Body.String())
}
}
// reworkAdvanceToNextReview 模拟标注员返工送检后回到质检:阶段/归属/修订号就位
// (不驱动完整送检端点,本票只考察退回路径的基线构造)。
func reworkAdvanceToNextReview(t *testing.T, f combinedDraftFixture) {
t.Helper()
item, e := f.store.GetHumanItem(f.ctx, f.item.ID)
if e != nil || item == nil {
t.Fatal(e)
}
item.CurrentStageID = domain.FanyuV58StageQualityReview
item.Status = domain.HumanItemClaimed
item.AssignedUserID = f.reviewer.ID
item.CurrentRevision++
item.Version++
if e := f.store.UpsertHumanItem(f.ctx, *item); e != nil {
t.Fatal(e)
}
task, e := f.store.GetAnnotationTask(f.ctx, f.task.ID)
if e != nil || task == nil {
t.Fatal(e)
}
task.CurrentRevision = item.CurrentRevision
task.Status = domain.AnnotationTaskStatusPendingQuality
if e := f.store.UpsertAnnotationTask(f.ctx, *task); e != nil {
t.Fatal(e)
}
}
func reworkContractFixture(t *testing.T) combinedDraftFixture {
t.Helper()
f := decisionFixture(t)
f.item.LatestAuthorUserID = f.annotator.ID
f.item.SupplierID = f.annotator.SupplierID
f.task.SupplierID = f.annotator.SupplierID
f.item.MaxReworkRounds = 5
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
if err := f.store.UpsertAnnotationTask(f.ctx, f.task); err != nil {
t.Fatal(err)
}
return f
}
func readBaselineProblems(t *testing.T, f combinedDraftFixture, rawRound string) (int, []domain.ReviewProblem) {
t.Helper()
endpoint := "/api/human-items/" + f.item.ID + "/rework-baseline"
if rawRound != "" {
endpoint += "?round=" + rawRound
}
w := f.request(http.MethodGet, endpoint, f.annotator, nil)
if w.Code != 200 {
t.Fatalf("baseline read %q: %d %s", rawRound, w.Code, w.Body.String())
}
var body struct {
Baseline *domain.ReworkBaselineRecord `json:"baseline"`
Round int `json:"round"`
}
json.Unmarshal(w.Body.Bytes(), &body)
if body.Baseline == nil {
return body.Round, nil
}
return body.Baseline.Round, body.Baseline.Problems
}
func problemIDs(problems []domain.ReviewProblem) []string {
ids := make([]string, 0, len(problems))
for _, p := range problems {
ids = append(ids, p.ID)
}
return ids
}
func TestReworkReturnBaselineUnresolvedOnlyAcrossRounds(t *testing.T) {
f := reworkContractFixture(t)
// round-1 退回:三条意见 → 基线(fixture 轮次 2)= 3 条。
reworkRejectRound(t, f, "contract-reject-1", []map[string]any{
{"id": "op-a", "scope": "slice", "sliceId": "left", "text": "甲意见"},
{"id": "op-b", "scope": "task", "text": "乙意见"},
{"id": "op-c", "scope": "slice", "sliceId": "right", "text": "丙意见"},
}, nil)
item, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
if item.ReviewRound != 2 {
t.Fatalf("round-1 rejection must advance ReviewRound to 2: %d", item.ReviewRound)
}
frozen, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(item.ID, 2))
if frozen == nil || len(frozen.Problems) != 3 {
t.Fatalf("round-1 baseline must freeze 3 opinions: %+v", frozen)
}
// 标注员返工送检 → round-2 复审:op-a/op-b 判已解决,op-c 判"仍有问题"(含
// 质检备注),另写两条新意见 → 再退回。
reworkAdvanceToNextReview(t, f)
reworkRejectRound(t, f, "contract-reject-2", []map[string]any{
{"id": "op-d", "scope": "slice", "sliceId": "left", "text": "丁意见"},
{"id": "op-e", "scope": "task", "text": "戊意见"},
}, []map[string]any{
{"opinionId": "op-a", "resolved": true, "note": "已核对修正"},
{"opinionId": "op-b", "resolved": true},
{"opinionId": "op-c", "resolved": false, "note": "改后区间仍多 2 秒"},
})
item, _ = f.store.GetHumanItem(f.ctx, f.item.ID)
if item.ReviewRound != 3 {
t.Fatalf("round-2 rejection must advance ReviewRound to 3: %d", item.ReviewRound)
}
// 新基线(轮次 3)= 1 条未解决旧意见(同条目、备注并入)+ 2 条新增。
next, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(item.ID, 3))
if next == nil {
t.Fatal("round-2 baseline missing")
}
if got, want := problemIDs(next.Problems), []string{"op-c", "op-d", "op-e"}; strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("round-2 baseline = %v, want %v(未解决在前、新增在后)", got, want)
}
if next.Problems[0].Text != "丙意见\n【质检备注】改后区间仍多 2 秒" {
t.Fatalf("仍有问题意见必须同条目并入备注(R2-Q7): %q", next.Problems[0].Text)
}
// 消费接口(标注员侧默认当前轮):字段不变,只收窄 problems 内容。
round, problems := readBaselineProblems(t, f, "")
if round != 3 || len(problems) != 3 || problems[0].ID != "op-c" {
t.Fatalf("current-round read: round=%d problems=%+v", round, problems)
}
// 历史轮次查询:已解决意见在任何基线查询接口都不再返回。
round, problems = readBaselineProblems(t, f, "2")
if round != 2 || len(problems) != 1 || problems[0].ID != "op-c" || problems[0].Text != "丙意见" {
t.Fatalf("historical round-2 read must hide resolved op-a/op-b: round=%d %+v", round, problems)
}
round, problems = readBaselineProblems(t, f, "1")
if round != 1 || problems != nil {
t.Fatalf("never-created round-1 baseline must stay null: round=%d %+v", round, problems)
}
// 冻结记录不动:round-2 基线在存储中仍保完整 3 条(审计轨迹,B02 保持)。
frozen, _ = f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(item.ID, 2))
if frozen == nil || len(frozen.Problems) != 3 {
t.Fatalf("frozen baseline record must keep the full audit trail: %+v", frozen)
}
}
func TestReworkBaselineLegacyRoundsDefaultUnresolved(t *testing.T) {
f := reworkContractFixture(t)
// 旧多轮数据:直接冻结的 round-1 基线(无任何核对结论记录)。
item, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
item.ReviewRound = 1
item.Version++
if e := f.store.UpsertHumanItem(f.ctx, *item); e != nil {
t.Fatal(e)
}
if e := f.store.UpsertReworkBaseline(f.ctx, domain.ReworkBaselineRecord{
ID: store.ReworkBaselineID(item.ID, 1), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID,
ItemID: item.ID, BatchID: item.BatchID, Round: 1, StageID: domain.FanyuV58StageAnnotationCombined,
Problems: []domain.ReviewProblem{
{ID: "lg-a", Scope: "slice", SliceID: "left", Text: "旧意见一"},
{ID: "lg-b", Scope: "task", Text: "旧意见二"},
},
}); e != nil {
t.Fatal(e)
}
// 旧客户端再退回:不送核对结论,只写新意见 → 兜底按未解决全量延续 + 新增。
reworkRejectRound(t, f, "legacy-reject", []map[string]any{
{"id": "lg-c", "scope": "slice", "sliceId": "left", "text": "新意见"},
}, nil)
item, _ = f.store.GetHumanItem(f.ctx, f.item.ID)
next, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(item.ID, 2))
if next == nil {
t.Fatal("legacy rejection must still freeze a baseline")
}
if got, want := problemIDs(next.Problems), []string{"lg-a", "lg-b", "lg-c"}; strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("legacy fallback must carry all prior opinions unresolved: %v, want %v", got, want)
}
// 历史轮查询无核对结论 → 不过滤,照常返回。
if _, problems := readBaselineProblems(t, f, "1"); len(problems) != 2 {
t.Fatalf("legacy round without confirmations must stay visible: %+v", problems)
}
}

View File

@ -29,12 +29,14 @@ func (s *server) handleReworkBaseline(w http.ResponseWriter, r *http.Request) {
round = parsed
}
}
baseline, e := s.store.GetReworkBaseline(r.Context(), store.ReworkBaselineID(item.ID, round))
// R1-Q8(ADR 0008):任何轮次的基线查询都收窄为"未解决意见"视图——历史
// 轮次已判解决的意见彻底不返回(不折叠);完整轨迹走正式审查记录。
// 缺快照时返回空基线(旧数据/早期轮次),调用方降级读旧基线,不阻塞流程。
baseline, e := s.visibleReworkBaseline(r.Context(), *item, round)
if e != nil {
renderError(w, http.StatusInternalServerError, e)
return
}
// 缺快照时返回空基线(旧数据/早期轮次),调用方降级读旧基线,不阻塞流程。
renderJSON(w, http.StatusOK, map[string]any{"baseline": baseline, "round": round})
}

View File

@ -32,7 +32,7 @@ import {
Volume2,
X,
} from "lucide-react";
import type { ReworkEmphasisView, ReworkOpinionView } from "../lib/rework-emphasis-types";
import type { ReworkEmphasisView, ReworkLocatePlan, ReworkOpinionView } from "../lib/rework-emphasis-types";
import type { AnnotationLabelRecord, AnnotationSegment, SemanticLabelDefinition, SliceSegment } from "../types";
import {
CAPTURE_PLAYBACK_RATES,
@ -41,6 +41,7 @@ import {
annotationEventOverlaps,
annotationConfirmationInterval,
annotationSegmentsForSlice,
archivedAnnotationsForSlice,
annotationDraftAtPlayhead,
annotationDraftCheckAtPlayhead,
annotationCoverageGaps,
@ -60,7 +61,7 @@ import { MoviVideo, moviElementReady } from "./MoviVideo";
import { loadMoviPlayer, moviRuntimeMode } from "../lib/movi-player";
import { ReworkOpinionRail } from "./ReworkOpinionRail";
import { ReworkProblemSubtitles } from "./ReworkProblemSubtitles";
import { reworkSubtitleRows } from "../lib/rework-emphasis.js";
import { reworkLocatePlan, reworkSubtitleRows } from "../lib/rework-emphasis.js";
import { cn } from "../lib/utils";
import { intervalStyle } from "../lib/timeline-viewport.js";
import {
@ -503,6 +504,9 @@ export function CaptureAnnotationWorkbench({
// §3.4 切片编辑模式:annotate 相内的模态键位层(E 进/出)。激活期间键位由
// sliceEditShortcut 独立键表分发,高亮边界复用 selectedBoundary(共享分界手柄)。
const [sliceEditActive, setSliceEditActive] = useState(false);
// 批 0 I2b:单切片按 E 的可见提示(短暂停留后自动消失,重按刷新计时)。
const [sliceEditBlocked, setSliceEditBlocked] = useState(false);
const sliceEditBlockedTimerRef = useRef<number | null>(null);
// §3.1/§3.2 处置卡的键盘焦点行(选择状态在页面侧,这里只记 UI 焦点)。
const [triageActiveRow, setTriageActiveRow] = useState(0);
useEffect(() => {
@ -517,6 +521,15 @@ export function CaptureAnnotationWorkbench({
const [splitPreview, setSplitPreview] = useState<SplitPreview>(null);
const [editingAnnotation, setEditingAnnotation] = useState<AnnotationSegment | null>(null);
const [parkedEditors, setParkedEditors] = useState<Record<string, SliceEditor>>({});
// 意见定位决策(reworkLocatePlan)用的停泊视图:sliceId → 停泊编辑器动作 id。
// 目标片有停泊草稿时跳转不自动开新编辑器,交回 selectSlice 恢复停泊态。
const parkedAnnotationBySlice = useMemo(() => {
const ids: Record<string, string> = {};
for (const entry of Object.entries(parkedEditors) as Array<[string, SliceEditor]>) {
ids[entry[0]] = entry[1].annotation.id;
}
return ids;
}, [parkedEditors]);
const [workPosition, setWorkPosition] = useState<number | null>(null);
const [reviewPlayback, setReviewPlayback] = useState(false);
// Review and navigation must never move an unfinished action's end point.
@ -621,13 +634,14 @@ export function CaptureAnnotationWorkbench({
setDispositionError("");
}
}, [selectedSlice?.id, dispositionOpen, dispositionDraft.sliceId]);
// 切片编辑模式只在 annotate 相的可编辑工作台内存在;阶段流转或只读化时自动退出并复位键位。
// 切片编辑模式只在 annotate 相的可编辑工作台内存在;阶段流转、只读化或模式内
// 合并到不足两条切片(无边界可挪)时自动退出并复位键位,不留全键静默的死模式。
useEffect(() => {
if (sliceEditActive && (phase !== "annotate" || readOnly || isQualityReview || mediaOnly)) {
if (sliceEditActive && (phase !== "annotate" || readOnly || isQualityReview || mediaOnly || slices.length < 2)) {
setSliceEditActive(false);
setSelectedBoundary(null);
}
}, [sliceEditActive, phase, readOnly, isQualityReview, mediaOnly]);
}, [sliceEditActive, phase, readOnly, isQualityReview, mediaOnly, slices]);
const playbackBounds = capturePlaybackBounds(phase, selectedSlice, clipStart, clipEnd, reviewPlayback);
const playheadSliceIndex = sliceIndexAtPlayhead(slices, currentTime);
const playheadSlice = playheadSliceIndex >= 0 ? slices[playheadSliceIndex] : null;
@ -662,6 +676,9 @@ export function CaptureAnnotationWorkbench({
: [...annotationSegments, editingAnnotation]
).sort((left, right) => left.start - right.start);
}, [annotationSegments, editingAnnotation]);
// 弃用片动作栏(I4):栏保留挂载,只读展示随片归档动作(审核证据,
// SliceSegment.discardedAnnotations);非弃用片行为不变,仍显示活动标注列表。
const actionListForRender = selectedDiscarded ? archivedAnnotationsForSlice(selectedSlice) : annotationForRender;
const [showActionJSON, setShowActionJSON] = useState(false);
const actionListRef = useRef<HTMLDivElement>(null);
@ -1165,19 +1182,19 @@ export function CaptureAnnotationWorkbench({
reworkJumpIndexRef.current = ((reworkJumpIndexRef.current + direction) % count + count) % count;
const target = order[reworkJumpIndexRef.current];
setReworkFocus({ opinionId: target.opinion.id, seq: (reworkFocus?.seq || 0) + 1 });
const anchor = typeof target.anchor === "number" && target.anchor >= 0 ? target.anchor : null;
if (target.sliceId) {
const slice = slices.find((item) => item.id === target.sliceId);
if (slice && slice.id !== selectedSlice.id) {
selectSlice(slice, anchor ?? slice.start, false);
return;
}
}
if (anchor != null) {
// J/K 定位只移动进度条,不自动播放:播放由播放键/空格触发(用户确认)。
pausePlayback();
seek(anchor);
}
// I1:跨片跳到锚定动作的意见时镜像点击路径,自动打开该动作编辑器;
// 同片仍只 seek 不重开面板(现状保持)。决策规则见 reworkLocatePlan。
executeReworkLocatePlan(
reworkLocatePlan({
mode: "jump",
opinion: target.opinion,
anchor: target.anchor,
selectedSliceId: selectedSlice.id,
slices,
segments,
parkedAnnotationBySlice,
}) as ReworkLocatePlan,
);
};
/** 卡片/标记点击定位:切片内时间用绝对秒;动作卡片跳到所属动作。 */
const sliceIdCovering = (start: number, end: number) => {
@ -1188,34 +1205,19 @@ export function CaptureAnnotationWorkbench({
};
const locateReworkOpinion = (opinion: ReworkOpinionView) => {
setReworkFocus({ opinionId: opinion.id, seq: (reworkFocus?.seq || 0) + 1 });
if (opinion.actionId) {
const segment = segments.find((item) => item.id === opinion.actionId);
if (segment) {
const ownerSliceId = sliceIdCovering(segment.start, segment.end);
if (ownerSliceId && ownerSliceId !== selectedSlice.id) {
const slice = slices.find((item) => item.id === ownerSliceId);
if (slice) {
selectSlice(slice, segment.start, false);
return;
}
}
seekAnnotation(segment, "start");
return;
}
}
const at = typeof opinion.atSeconds === "number" ? opinion.atSeconds : null;
if (opinion.sliceId) {
const slice = slices.find((item) => item.id === opinion.sliceId);
if (slice && slice.id !== selectedSlice.id) {
selectSlice(slice, at ?? slice.start, false);
return;
}
}
if (at != null) {
// 点击定位与 J/K 同语义:定位即暂停,不自动播放。
pausePlayback();
seek(at);
}
// 点击路径与 J/K 跳转共用 reworkLocatePlan:跨片锚定动作同样自动打开
// 编辑器(I1 对齐),同片点击仍走 seekAnnotation 点开动作(既有行为)。
executeReworkLocatePlan(
reworkLocatePlan({
mode: "click",
opinion,
anchor: typeof opinion.atSeconds === "number" ? opinion.atSeconds : null,
selectedSliceId: selectedSlice.id,
slices,
segments,
parkedAnnotationBySlice,
}) as ReworkLocatePlan,
);
};
const toggleReworkSkip = (opinionId: string, skipped: boolean) => {
onReworkSkipToggle?.(opinionId, skipped);
@ -1355,7 +1357,24 @@ export function CaptureAnnotationWorkbench({
};
// —— §3.4 切片编辑模式(annotate 相模态键位层)——
// 批 0 I2b:单切片无可调边界,按 E 只弹提示不进模式(停留 2.5s,重按重置)。
const notifySliceEditUnavailable = () => {
setSliceEditBlocked(true);
if (sliceEditBlockedTimerRef.current !== null) window.clearTimeout(sliceEditBlockedTimerRef.current);
sliceEditBlockedTimerRef.current = window.setTimeout(() => {
sliceEditBlockedTimerRef.current = null;
setSliceEditBlocked(false);
}, 2500);
};
useEffect(
() => () => {
if (sliceEditBlockedTimerRef.current !== null) window.clearTimeout(sliceEditBlockedTimerRef.current);
},
[],
);
const enterSliceEditMode = () => {
// 单切片任务无边界可挪,禁入(提示由分发处 slice-edit-unavailable 给出)。
if (slices.length < 2) return;
// 与切分 C 同款前置:正在编辑动作描述时不进入,先保存或取消。
if (!continuousActions && editingAnnotation) return;
pausePlayback();
@ -2068,6 +2087,37 @@ export function CaptureAnnotationWorkbench({
focusWorkbench();
};
/** 跨片定位后打开意见锚定的动作编辑器(I1:J/K 与点击路径对齐)。
* 仅在 reworkLocatePlan 判定目标片可编辑(非弃用、无停泊草稿)时到达:
* selectSlice 已把目标片停泊态恢复为当前编辑态,这里直接展示锚定动作;
* 滚动语义与 seekAnnotation 一致——动作栏行滚入视野,不额外滚动页面。 */
const openAnchoredEditor = (segment: AnnotationSegment) => {
descriptionNavigationRef.current = segment.id !== editingAnnotation?.id;
setEditingAnnotation(segment);
setEndSelection(null);
};
/** 意见定位执行器:J/K 跳转与意见卡点击共用 reworkLocatePlan 的计划。 */
const executeReworkLocatePlan = (plan: ReworkLocatePlan) => {
if (plan.kind === "select") {
selectSlice(plan.slice, plan.time, false);
if (plan.openActionId) {
const segment = segments.find((item) => item.id === plan.openActionId);
if (segment) openAnchoredEditor(segment);
}
return;
}
if (plan.kind === "annotate") {
seekAnnotation(plan.segment, "start");
return;
}
if (plan.time != null) {
// 定位即暂停,不自动播放:播放由播放键/空格触发(用户确认)。
pausePlayback();
seek(plan.time);
}
};
const navigateAnnotation = (direction: -1 | 1, count = 1) => {
let target = adjacentAnnotation(annotationForRender, editingAnnotation?.id, currentTime, direction);
if (continuousActions && !isReviewViewing && annotationForRender.length) {
@ -2667,6 +2717,8 @@ export function CaptureAnnotationWorkbench({
selectingEnd,
phase,
continuousActions,
// 批 0 I2b:切片数不足两条时 E 改发 slice-edit-unavailable(提示)不进模式。
sliceEditEntry: slices.length > 1,
},
);
if (!action) return;
@ -2717,6 +2769,7 @@ export function CaptureAnnotationWorkbench({
: void deleteAnnotationLeavingBlank(editingAnnotation.id);
} else if (action === "mark-invalid" && phase === "annotate") void markSelectedInvalid();
else if (action === "toggle-slice-edit" && phase === "annotate") enterSliceEditMode();
else if (action === "slice-edit-unavailable" && phase === "annotate") notifySliceEditUnavailable();
else if (action === "new" && phase === "annotate" && sliceAligned) addAnnotation();
else if (action === "confirm-end" && selectingEnd && editingAnnotation) confirmEndSelection();
else if (action === "edit-description" && editingAnnotation && !selectingEnd)
@ -2728,16 +2781,17 @@ export function CaptureAnnotationWorkbench({
}
}}
>
{continuousActions && phase === "annotate" && !selectedDiscarded && (
{continuousActions && phase === "annotate" && (
<aside className="capture-action-list" aria-label="当前切片动作列表">
<strong>动作 · {annotationForRender.length}</strong>
<strong>动作 · {actionListForRender.length}</strong>
<div ref={actionListRef} role="listbox" aria-label="动作区间" className="capture-action-list-scroll">
{annotationForRender.map((action, index) => (
{actionListForRender.map((action, index) => (
<button
key={action.id}
type="button"
role="option"
aria-selected={editingAnnotation?.id === action.id}
disabled={selectedDiscarded}
data-rework-red={(reworkActive ? reworkActionBuckets.get(action.id)?.red.length || 0 : 0) > 0 || undefined}
onClick={() => seekAnnotation(action, "end")}
>
@ -3738,20 +3792,33 @@ export function CaptureAnnotationWorkbench({
) : null}
</div>
) : null}
{sliceEditActive && phase === "annotate" ? (
<div
data-testid="slice-edit-mode-banner"
className="mb-1 flex flex-wrap items-center gap-x-3 gap-y-0.5 rounded-md border border-orange-400 bg-orange-50 px-2.5 py-1.5 text-[11px] font-medium text-orange-800 dark:border-orange-600 dark:bg-orange-950/40 dark:text-orange-200"
>
<span className="font-bold">切片编辑模式</span>
<span>←/→ 逐帧挪高亮边界</span>
<span>Shift+←/→ 0.5 秒粗步进</span>
<span>↑/↓ 切换边界</span>
<span>G 舍弃当前片</span>
<span>E / Esc 退出</span>
<span className="font-normal text-orange-700/80 dark:text-orange-300/80">
鼠标拖手柄、悬停+、垃圾桶合并仍可用
</span>
{/* 批 0 I2a:恒定占位槽 + 绝对定位浮层——进出 E 模式时间轴轨道像素级零位移。 */}
{phase === "annotate" ? (
<div data-testid="slice-edit-banner-slot" className="relative z-10 mb-1 h-8">
{sliceEditActive ? (
<div
data-testid="slice-edit-mode-banner"
className="absolute inset-x-0 top-0 flex flex-wrap items-center gap-x-3 gap-y-0.5 rounded-md border border-orange-400 bg-orange-50 px-2.5 py-1.5 text-[11px] font-medium text-orange-800 dark:border-orange-600 dark:bg-orange-950/40 dark:text-orange-200"
>
<span className="font-bold">切片编辑模式</span>
<span>←/→ 逐帧挪高亮边界</span>
<span>Shift+←/→ 0.5 秒粗步进</span>
<span>↑/↓ 切换边界</span>
<span>G 舍弃当前片</span>
<span>E / Esc 退出</span>
<span className="font-normal text-orange-700/80 dark:text-orange-300/80">
鼠标拖手柄、悬停+、垃圾桶合并仍可用
</span>
</div>
) : sliceEditBlocked ? (
<div
data-testid="slice-edit-unavailable-notice"
role="status"
className="absolute inset-x-0 top-0 flex flex-wrap items-center rounded-md border border-slate-300 bg-slate-50 px-2.5 py-1.5 text-[11px] font-medium text-slate-600 dark:border-slate-600 dark:bg-slate-800/60 dark:text-slate-300"
>
仅一个切片,无可调边界
</div>
) : null}
</div>
) : null}
<div

View File

@ -9,6 +9,7 @@ export function annotationShortcut(
selectingEnd = false,
phase = "annotate",
continuousActions = false,
sliceEditEntry = true,
} = {},
) {
if (event.defaultPrevented || event.isComposing || event.keyCode === 229) return null;
@ -80,7 +81,14 @@ export function annotationShortcut(
Enter: descriptionEditor ? "edit-description" : "confirm-end",
f: "dictionary",
d: "dictionary",
e: phase === "annotate" ? "toggle-slice-edit" : null,
// 批 0 I2b:单切片任务(sliceEditEntry=false)无可调边界,E 不再进模式,
// 改发 slice-edit-unavailable 由工作台提示;双切片以上默认行为逐键不变。
e:
phase === "annotate"
? sliceEditEntry
? "toggle-slice-edit"
: "slice-edit-unavailable"
: null,
g: phase === "annotate" ? "mark-invalid" : phase === "slice" ? "discard-dictionary" : null,
1: "slow",
2: "normal",

View File

@ -99,6 +99,15 @@ export function annotationSegmentsForSlice(slice, segments = []) {
return (segments ?? []).filter((segment) => segment.start >= slice.start && segment.end <= slice.end);
}
// 弃用片的归档动作列表(票 slice-edit-ux-rework 02 · I4):
// annotationSegmentsForSlice 对弃用片返回空(活动标注不进弃用片),动作栏
// 只读展示的是随片保留的审核证据(SliceSegment.discardedAnnotations),
// 按起点稳定排序并返回副本;非弃用片/无归档返回空数组。
export function archivedAnnotationsForSlice(slice) {
if (!slice || slice.deliveryDisposition !== "discard") return [];
return [...(slice.discardedAnnotations ?? [])].sort((left, right) => left.start - right.start);
}
export function normalizeFrameBoundaries(boundaries = [], clipStart = 0, clipEnd = Number.POSITIVE_INFINITY) {
const lower = Number.isFinite(Number(clipStart)) ? Number(clipStart) : 0;
const upper = Number.isFinite(Number(clipEnd)) ? Number(clipEnd) : Number.POSITIVE_INFINITY;

View File

@ -3,6 +3,8 @@
// 标注员工作台与 QC 返修接收视图共用,独立成文件后 QC 视图不再
// 反向依赖 5.5k 行巨型组件。零行为变化,字段与原定义完全一致。
import type { AnnotationSegment, SliceSegment } from "../types";
/** 返工强调层的一条意见投影(rework-emphasis.js 计算结果的结构契约)。 */
export type ReworkOpinionView = {
id: string;
@ -39,3 +41,28 @@ export type ReworkEmphasisView = {
state: "red" | "gray" | "skipped" | "old";
}>;
};
/**
* 意见定位计划(rework-emphasis.js reworkLocatePlan 的结构契约,票 slice-edit-ux-rework 02 · I1):
* J/K 键盘跳转与意见卡点击共用,保证两条路径定位行为一致。
*/
export type ReworkLocatePlan =
| {
/** 跨片切选:切到目标片并 seek 到 time。 */
kind: "select";
slice: SliceSegment;
time: number;
/** 意见锚定动作且目标片可编辑时指向该动作——切片后自动打开其编辑器;否则 null。 */
openActionId: string | null;
}
| {
/** 同片点开锚定动作编辑器(点击路径既有行为;键盘路径不产生)。 */
kind: "annotate";
segment: AnnotationSegment;
time: number;
}
| {
/** 仅移动进度条(time 为 null 时不动进度条,只更新意见焦点)。 */
kind: "seek";
time: number | null;
};

View File

@ -377,6 +377,57 @@ export function nextReworkJump(emphasis, index, direction) {
return { entry: emphasis.jumpOrder[next], index: next };
}
// 意见定位的统一决策(票 slice-edit-ux-rework 02 · I1 键盘/点击路径对齐):
// J/K 键盘跳转(mode="jump")与意见卡点击(mode="click")共用,保证两条路径
// 对同一条意见产生一致的定位行为。返回纯数据计划,由工作台执行:
// - { kind: "select", slice, time, openActionId }:跨片切选;意见锚定动作且
// 目标片可编辑(非弃用、无停泊草稿)时 openActionId 指向锚定动作,
// 工作台在 selectSlice 后自动打开该动作编辑器(镜像点击路径既有行为);
// 目标片弃用或已有停泊编辑器(未保存草稿)时置 null——弃用片不提供编辑
// 入口(I4 只读),停泊草稿由 selectSlice 恢复、不得被跳转覆盖。
// - { kind: "annotate", segment, time }:同片点开锚定动作编辑器(点击路径
// 既有行为;键盘路径不产生——同片 J/K 只 seek 不重开面板,现状保持)。
// - { kind: "seek", time }:仅移动进度条(time 为 null 时不动进度条)。
// 动作归属用 sliceCovering 的几何语义(与强调层判定一致);锚定动作已删除
// (segments 里找不到)时退回切片/时间点分支。
export function reworkLocatePlan({
mode,
opinion,
anchor,
selectedSliceId,
slices,
segments,
parkedAnnotationBySlice = {},
}) {
const actionId = opinion?.actionId ?? null;
if (actionId) {
const segment = (segments ?? []).find((item) => item.id === actionId);
if (segment) {
const owner = sliceCovering(slices ?? [], segment.start, segment.end);
if (owner && owner.id !== selectedSliceId) {
const parked = parkedAnnotationBySlice[owner.id] ?? null;
return {
kind: "select",
slice: owner,
time: segment.start,
openActionId: owner.deliveryDisposition === "discard" || parked ? null : segment.id,
};
}
if (mode === "click") return { kind: "annotate", segment, time: segment.start };
// jump 同片:只 seek,不重开面板(现状保持),落入下方公共分支。
}
}
const at = typeof anchor === "number" && anchor >= 0 ? anchor : null;
const sliceId = opinion?.sliceId ?? null;
if (sliceId) {
const slice = (slices ?? []).find((item) => item.id === sliceId);
if (slice && slice.id !== selectedSliceId) {
return { kind: "select", slice, time: at ?? slice.start, openActionId: null };
}
}
return { kind: "seek", time: at };
}
// 意见字幕(视频画面三排小字)行模型:跟播放头位置匹配(用户确认的设计)——
// - 切片排:播放头所在切片的切片级意见(整片有效);
// - 动作/时间点排:只显示播放头当前所在动作(actionId 匹配)的意见,

View File

@ -415,6 +415,27 @@ test("E toggles the slice-edit mode only in annotate and every other annotate ke
assert.equal(annotationShortcut(key("ArrowDown", { ctrlKey: true }), { phase: "annotate" }), "annotation-end");
});
test("E reports unavailable when fewer than two slices leave no adjustable boundary", () => {
// 批 0 I2b:单切片任务按 E 不再静默进死模式——映射层改发 slice-edit-unavailable,
// 由工作台给「仅一个切片,无可调边界」提示;双切片以上(默认)逐键不变。
for (const input of ["e", "E"])
assert.equal(
annotationShortcut(key(input), { phase: "annotate", sliceEditEntry: false }),
"slice-edit-unavailable",
);
assert.equal(annotationShortcut(key("e"), { phase: "annotate" }), "toggle-slice-edit");
assert.equal(annotationShortcut(key("E"), { phase: "annotate", sliceEditEntry: true }), "toggle-slice-edit");
assert.equal(annotationShortcut(key("e"), { phase: "slice", sliceEditEntry: false }), null);
assert.equal(annotationShortcut(key("e"), { phase: "materializing", sliceEditEntry: false }), null);
assert.equal(annotationShortcut(key("e"), { phase: "annotate", sliceEditEntry: false, editable: true }), null);
assert.equal(annotationShortcut(key("e", { ctrlKey: true }), { phase: "annotate", sliceEditEntry: false }), null);
// 按住 E 连发只吞不触发:提示不会随重复按键反复闪现。
assert.equal(
annotationShortcut(key("e", { repeat: true }), { phase: "annotate", sliceEditEntry: false }),
"consume",
);
});
test("help documents the slice-edit mode entry and its modal key table", () => {
const entry = annotationShortcutHelpForContext("annotate").find((row) => row.keys === "E");
assert.ok(entry, "annotate help lists the E entry");

View File

@ -464,3 +464,23 @@ test("canceling the final slice clears its left neighbor judgment and cannot rem
assert.equal(annotationWorkbench.cancelSlicePartition(result.slices, 0), null);
assert.equal(annotationWorkbench.mergeSlicePartitions([before[0], { ...before[1], start: 5 }], 0), null);
});
test("archivedAnnotationsForSlice: discarded slice lists its archived annotations read-only style; kept slices none", () => {
const archived = [
{ id: "a3", description: "第三段", start: 16, end: 20 },
{ id: "a2", description: "第二段", start: 12, end: 16 },
];
const discarded = { id: "s2", start: 10, end: 20, deliveryDisposition: "discard", discardedAnnotations: archived };
// 弃用片:归档动作按起点稳定排序、返回副本(不暴露原数组)。
const listed = annotationWorkbench.archivedAnnotationsForSlice(discarded);
assert.deepEqual(
listed.map((a) => a.id),
["a2", "a3"],
);
assert.notEqual(listed, archived);
// 保留片 / 无归档 / 空入参:不提供任何动作(动作列表仍走活动标注)。
const kept = { id: "s1", start: 0, end: 10 };
assert.deepEqual(annotationWorkbench.archivedAnnotationsForSlice(kept), []);
assert.deepEqual(annotationWorkbench.archivedAnnotationsForSlice({ ...kept, deliveryDisposition: "discard" }), []);
assert.deepEqual(annotationWorkbench.archivedAnnotationsForSlice(null), []);
});

View File

@ -106,6 +106,38 @@ test("Capture workbench follows the confirmed two-phase interaction", () => {
assert.doesNotMatch(workbench, /自动保存|高级模式|使用手别/);
});
test("slice-edit banner floats in a constant slot and single-slice tasks cannot enter E mode", () => {
// 批 0 I2a:横幅改恒定占位 + 绝对定位浮层——进出 E 模式时间轴轨道像素级零位移。
const slotStart = workbench.indexOf('data-testid="slice-edit-banner-slot"');
const bannerSlot = workbench.slice(slotStart, workbench.indexOf('data-testid="capture-slice-timeline"'));
assert.ok(slotStart >= 0, "annotate 阶段恒定挂载横幅槽位");
assert.match(workbench, /\{phase === "annotate" \?\s*\(\s*<div data-testid="slice-edit-banner-slot"/);
assert.match(bannerSlot, /relative z-10 mb-1 h-8/);
assert.match(bannerSlot, /data-testid="slice-edit-mode-banner"/);
assert.match(bannerSlot, /absolute inset-x-0 top-0/);
assert.doesNotMatch(bannerSlot, /className="mb-1 flex/);
// 批 0 I2b:单切片按 E 不进模式,改显可见提示;重按刷新停留计时。
assert.match(bannerSlot, /data-testid="slice-edit-unavailable-notice"/);
assert.match(bannerSlot, /仅一个切片,无可调边界/);
const enter = workbench.slice(
workbench.indexOf("const enterSliceEditMode ="),
workbench.indexOf("const exitSliceEditMode ="),
);
assert.match(enter, /slices\.length < 2/);
assert.ok(
enter.indexOf("slices.length < 2") < enter.indexOf("pausePlayback"),
"单切片拦在暂停播放等副作用之前",
);
assert.match(workbench, /action === "slice-edit-unavailable" && phase === "annotate"/);
assert.match(workbench, /sliceEditEntry: slices\.length > 1/);
// 模式激活期间合并/缩减到单切片时自动退出,不留全键静默的死模式。
const autoExit = workbench.slice(
workbench.indexOf("切片编辑模式只在 annotate 相"),
workbench.indexOf("const playbackBounds ="),
);
assert.match(autoExit, /slices\.length < 2/);
});
test("production shell keeps real users, collapsible navigation, and a persisted light-default theme", () => {
assert.match(app, /<UserProvider>/);
assert.match(app, /<ThemeProvider>/);

View File

@ -1,6 +1,12 @@
import assert from "node:assert/strict";
import test from "node:test";
import { computeReworkEmphasis, emptyReworkEmphasis, nextReworkJump, reworkSubtitleRows } from "../../src/lib/rework-emphasis.js";
import {
computeReworkEmphasis,
emptyReworkEmphasis,
nextReworkJump,
reworkLocatePlan,
reworkSubtitleRows,
} from "../../src/lib/rework-emphasis.js";
const baseline = {
round: 1,
@ -460,3 +466,129 @@ test("multi-round: round-2 stays red while restructured round-1 opinions follow
["red", "old", "old"],
);
});
// ---- reworkLocatePlan(票 slice-edit-ux-rework 02 · I1 键盘/点击路径对齐)----
// 定位决策共用输入:当前选中 s1;意见锚定 a2(几何归属 s2)。
const locateSlices = [
{ id: "s1", name: "拿取", start: 0, end: 10 },
{ id: "s2", name: "放回", start: 10, end: 20 },
];
const locateActions = [
{ id: "a1", description: "拿起商品", start: 0, end: 5 },
{ id: "a2", description: "放回商品", start: 12, end: 18 },
];
const locateBase = {
selectedSliceId: "s1",
slices: locateSlices,
segments: locateActions,
};
test("reworkLocatePlan: jump cross-slice to action-anchored opinion selects owner slice and opens anchored editor", () => {
const plan = reworkLocatePlan({
...locateBase,
mode: "jump",
opinion: { id: "op-a2", scope: "action", sliceId: "s2", actionId: "a2", atSeconds: 12 },
anchor: 12,
});
assert.equal(plan.kind, "select");
assert.equal(plan.slice.id, "s2");
assert.equal(plan.time, 12);
assert.equal(plan.openActionId, "a2");
});
test("reworkLocatePlan: click path mirrors jump cross-slice (same select+open plan) and opens editor same-slice", () => {
const clickCross = reworkLocatePlan({
...locateBase,
mode: "click",
opinion: { id: "op-a2", scope: "action", sliceId: "s2", actionId: "a2", atSeconds: 12 },
anchor: 12,
});
assert.deepEqual(
{ ...clickCross, slice: clickCross.slice.id },
{ kind: "select", slice: "s2", time: 12, openActionId: "a2" },
);
// 同片点击(既有行为保持):直接点开锚定动作编辑器。
const clickSame = reworkLocatePlan({
...locateBase,
mode: "click",
opinion: { id: "op-a1", scope: "action", sliceId: "s1", actionId: "a1", atSeconds: 1 },
anchor: 1,
});
assert.deepEqual({ ...clickSame, segment: clickSame.segment.id }, { kind: "annotate", segment: "a1", time: 0 });
});
test("reworkLocatePlan: discarded owner slice or parked draft keeps openActionId null (read-only / draft preserved)", () => {
const discardedSlices = [
{ id: "s1", name: "拿取", start: 0, end: 10 },
{ id: "s2", name: "放回", start: 10, end: 20, deliveryDisposition: "discard" },
];
const opinion = { id: "op-a2", scope: "action", sliceId: "s2", actionId: "a2", atSeconds: 12 };
const onDiscarded = reworkLocatePlan({
...locateBase,
slices: discardedSlices,
mode: "jump",
opinion,
anchor: 12,
});
assert.equal(onDiscarded.kind, "select");
assert.equal(onDiscarded.slice.id, "s2");
assert.equal(onDiscarded.openActionId, null);
// 目标片有停泊编辑器(未保存草稿):跳转不覆盖,交回 selectSlice 恢复。
const withParked = reworkLocatePlan({
...locateBase,
mode: "jump",
opinion,
anchor: 12,
parkedAnnotationBySlice: { s2: "a2" },
});
assert.equal(withParked.kind, "select");
assert.equal(withParked.openActionId, null);
});
test("reworkLocatePlan: preserved fallbacks — same-slice jump seeks only; slice/timestamp/task opinions keep legacy branches", () => {
// 同片 J/K(锚定动作在当前片):只 seek 不重开面板(现状保持)。
const jumpSame = reworkLocatePlan({
...locateBase,
mode: "jump",
opinion: { id: "op-a1", scope: "action", sliceId: "s1", actionId: "a1", atSeconds: 3 },
anchor: 3,
});
assert.deepEqual(jumpSame, { kind: "seek", time: 3 });
// 切片意见跨片:select,时间退回 atSeconds ?? slice.start。
const sliceOpinion = reworkLocatePlan({
...locateBase,
mode: "jump",
opinion: { id: "op-s2", scope: "slice", sliceId: "s2", text: "…" },
anchor: 15,
});
assert.deepEqual(
{ ...sliceOpinion, slice: sliceOpinion.slice.id },
{ kind: "select", slice: "s2", time: 15, openActionId: null },
);
const sliceNoAnchor = reworkLocatePlan({
...locateBase,
mode: "click",
opinion: { id: "op-s2", scope: "slice", sliceId: "s2", text: "…" },
anchor: null,
});
assert.equal(sliceNoAnchor.time, 10);
// 锚定动作已被删除:退回切片分支(跳转不再指向已删动作)。
const deletedAction = reworkLocatePlan({
...locateBase,
mode: "jump",
opinion: { id: "op-gone", scope: "action", sliceId: "s2", actionId: "aX", atSeconds: 14 },
anchor: 14,
});
assert.deepEqual(
{ ...deletedAction, slice: deletedAction.slice.id },
{ kind: "select", slice: "s2", time: 14, openActionId: null },
);
// 整体意见(无锚点无切片):只设焦点,不动进度条。
const taskOpinion = reworkLocatePlan({
...locateBase,
mode: "jump",
opinion: { id: "op-task", scope: "task", text: "…" },
anchor: -1,
});
assert.deepEqual(taskOpinion, { kind: "seek", time: null });
});