feat(release): 建批时冻结 + 验收通过自动批准 —— 把"每份文档 8 步"砍掉两步并去掉两次卡死

背景:发布管理把"逐条核验"的仪式强加给每一份文档。实测一份文档要 9~11 次交互,
且有两处顺序陷阱(冻结后批准 → 建批 422;生成即固化 → 批准被永久钉住)。

P0-1 建批时冻结:
- CreateReleaseBatch 在未指定版本时,自己把当前实时计划冻结成一份**已确认**版本并绑定
  (同一事务;同摘要复用最近版本,planned 或 confirmed 都可复用,因此同一份计划不堆版本)。
- 语义不变:批一旦建立,清单/摘要/验收轮次/目标库绑定全部不可变、回滚按它走;变的只是
  "谁在什么时候按固化键"——从操作员的手动两步变成建批这一下。
- 效果:去掉「生成新版本」「确认冻结」两步;消灭"批准晚于冻结 → 422"这类顺序陷阱;
  前端不再传版本 id,也不再有"所选知识不在冻结清单里"的阻断。
- 计划→清单项的映射抽成 ChangeSetItemsFromPlan 供两处共用,否则两处算出的摘要不同,
  "同一计划复用同一版本"永远不命中。

P0-2 验收通过自动批准:
- 验收三项结论达发布门槛(knowledge_exists/chunks_present=passed,retrieval_hit 与门槛同
  口径)时,由 worker 写入 reviewer_ref='system:auto' 的批准记录,替代"每份文档点一次批准"。
- 策略 TEST_AUTO_REVIEW_POLICY = off | internal(默认,仅对内)| all;值不认识拒绝启动。
  只影响审核这一步:生产授权、双闸与发布前快照门禁不受影响。界面上只读展示当前策略。
- 安全边界(写死在审核 SQL 里):系统只允许写"第一条"审核——人工一旦表过态,机器不得用一条
  更晚的 approved 把人工结论翻回去;人工随时可再审。集成测试去掉该约束即 FAIL(已实测)。
- 自动批准自身的任何失败都不影响验收结论,只上报。

顺带(P1-1 前半,已被 P0-1 取代的部分已删除):
- 写操作失败把服务端 {"error": ...} 的原因带出来,并对已知原因给出下一步(不再只给 HTTP 状态码)。
- 当前的"不在已冻结清单里"标注与就地修复按钮随 P0-1 一起移除(该失败模式已不存在)。

测试:bind_time_freeze_integration_test.go(绑定已确认版本/同计划复用/冻结后不可变/
动作不符仍 NotEligible)、auto_review_integration_test.go(系统只写第一条、人工可再审)、
validate_test.go(对内自动/对外不自动/策略关闭/验收未过不批/自身失败不影响验收)、
auto_review_test.go、config_test 及前端能力解析测试。
实测耗时:本机 Go 全量 26 包通过、前端 178 条通过。
This commit is contained in:
姚章浩
2026-10-10 15:05:20 +08:00
parent 32450a7c7b
commit acf053faf3
21 changed files with 630 additions and 44 deletions
+1
View File
@@ -122,6 +122,7 @@ func run(ctx context.Context, getenv func(string) string) error {
ProductionWeKnoraBaseURL: config.ProductionWeKnoraBaseURL,
ServiceTargetVerifier: serviceTargetVerifier,
ProductionReleaseRequestsEnabled: config.ProductionReleaseRequestsEnabled,
TestAutoReviewPolicy: config.TestAutoReviewPolicy,
ProductionBackupRestoreVerified: config.ProductionBackupRestoreVerified,
ProductionReleaseAuthorizerRef: config.ProductionReleaseAuthorizerRef,
ProductionReleaseAuthorizationToken: releaseAuthorizationToken,
+10 -3
View File
@@ -12,6 +12,7 @@ import (
"github.com/jackc/pgx/v5/pgxpool"
"knowledge-governance/internal/appconfig"
"knowledge-governance/internal/governance"
"knowledge-governance/internal/jobs"
postgresstore "knowledge-governance/internal/platform/postgres"
"knowledge-governance/internal/platform/weknora"
@@ -159,10 +160,16 @@ func workerHandlers(store *postgresstore.Store, config appconfig.Config) (map[st
if err != nil {
return nil, fmt.Errorf("create test poll handler: %w", err)
}
policy, err := governance.ParseAutoReviewPolicy(config.TestAutoReviewPolicy)
if err != nil {
return nil, fmt.Errorf("resolve test auto review policy: %w", err)
}
validate, err := testweknora.NewValidateHandler(testweknora.ValidateHandlerConfig{
Store: store,
Client: client,
PolicyVersion: config.TestAcceptancePolicyVersion,
Store: store,
Client: client,
PolicyVersion: config.TestAcceptancePolicyVersion,
AutoReviewPolicy: policy,
Report: func(err error) { log.Printf("auto review error: %v", err) },
})
if err != nil {
return nil, fmt.Errorf("create test validate handler: %w", err)
+3
View File
@@ -33,6 +33,9 @@ services:
WORKER_LEASE_DURATION: 30s
WORKER_RETRY_DELAY: 5s
TEST_WEKNORA_BASE_URL: "${TEST_WEKNORA_BASE_URL:-}"
# 验收通过后是否自动批准:off | internal(默认,仅对内;对外仍需人工)| all。
# 只影响"审核"这一步;生产发布的双闸、人工授权与发布前快照门禁不受影响。
TEST_AUTO_REVIEW_POLICY: "${TEST_AUTO_REVIEW_POLICY:-internal}"
DINGTALK_LOGIN_SIDECAR_URL: "http://dingtalk-login:8091"
MINERU_BASE_URL: "${MINERU_BASE_URL:-}"
TEST_INTERNAL_WEKNORA_KB_ID: "${TEST_INTERNAL_WEKNORA_KB_ID:-1b52c140-2e18-4676-afc5-4c7d8d190a8c}"
+9
View File
@@ -53,6 +53,8 @@ type Config struct {
TestWeKnoraStalledAfter time.Duration
TestWeKnoraMaxUploadBytes int64
TestAcceptancePolicyVersion string
// TestAutoReviewPolicy:验收通过后是否自动批准(off|internal|all;默认 internal)。
TestAutoReviewPolicy string
// 目标库所在主机(整库逻辑备份真正执行的地方)。凭据是挂载进来的 0600 ssh
// 配置文件与私钥;三项同时给出才接线,缺任一项即"未接线"(页面降级展示)。
BackupHostSSHConfig string
@@ -94,6 +96,7 @@ func Load(getenv func(string) string) (Config, error) {
TestWeKnoraStalledAfter: 30 * time.Minute,
TestWeKnoraMaxUploadBytes: 50 * 1024 * 1024,
TestAcceptancePolicyVersion: valueOrDefault(getenv("TEST_ACCEPTANCE_POLICY_VERSION"), "structural-v1"),
TestAutoReviewPolicy: valueOrDefault(getenv("TEST_AUTO_REVIEW_POLICY"), string(governance.AutoReviewInternal)),
// 整库逻辑备份的目标主机:三项同时给出才接线(脚本目录/备份根有默认值)。
BackupHostSSHConfig: strings.TrimSpace(getenv("BACKUP_HOST_SSH_CONFIG")),
BackupHostTarget: strings.TrimSpace(getenv("BACKUP_HOST_TARGET")),
@@ -208,6 +211,12 @@ func Load(getenv func(string) string) (Config, error) {
if config.TestAcceptancePolicyVersion == "" {
return Config{}, errors.New("TEST_ACCEPTANCE_POLICY_VERSION must not be empty")
}
// 审核策略:值不认识就拒绝启动,避免"写错一个词 → 静默变成另一种审核强度"。
normalizedPolicy, err := governance.ParseAutoReviewPolicy(config.TestAutoReviewPolicy)
if err != nil {
return Config{}, errors.New("TEST_AUTO_REVIEW_POLICY must be one of off, internal, all")
}
config.TestAutoReviewPolicy = string(normalizedPolicy)
if config.ProductionReleaseRequestsEnabled {
// 目标主机凭据要么都给要么都不给:只给一半会把"未接线"伪装成"已接线"。
if (config.BackupHostSSHConfig == "") != (config.BackupHostTarget == "") {
+66
View File
@@ -0,0 +1,66 @@
package governance
import (
"errors"
"strings"
)
// AutoReviewPolicy 决定「验收通过的知识是否由系统自动写入审核批准」。
//
// 目的:把运维从「每份文档都点一次批准」里解放出来。它只影响审核这一步,
// 生产发布的人工授权、双闸(请求门禁 + 备份验证门禁)与发布前快照门禁都不受影响。
type AutoReviewPolicy string
const (
// AutoReviewOff:不做自动批准,全部人工。
AutoReviewOff AutoReviewPolicy = "off"
// AutoReviewInternal:仅「对内」自动批准,「对外」(客户可见)仍需人工。
AutoReviewInternal AutoReviewPolicy = "internal"
// AutoReviewAll:对内对外都自动批准。
AutoReviewAll AutoReviewPolicy = "all"
)
// ErrInvalidAutoReviewPolicy:策略值不认识。配置异常要拒绝启动,而不是悄悄降级成某个默认值。
var ErrInvalidAutoReviewPolicy = errors.New("invalid auto review policy")
// ParseAutoReviewPolicy 解析策略:空值取默认「仅对内」,未知值报错。
func ParseAutoReviewPolicy(value string) (AutoReviewPolicy, error) {
switch strings.ToLower(strings.TrimSpace(value)) {
case "":
return AutoReviewInternal, nil
case string(AutoReviewOff):
return AutoReviewOff, nil
case string(AutoReviewInternal):
return AutoReviewInternal, nil
case string(AutoReviewAll):
return AutoReviewAll, nil
default:
return "", ErrInvalidAutoReviewPolicy
}
}
// Allows 判断某个目标范围的知识是否允许自动批准。范围值不认识时一律不允许(fail-closed)。
func (policy AutoReviewPolicy) Allows(targetScope string) bool {
switch policy {
case AutoReviewInternal:
return targetScope == string(VisibilityInternal)
case AutoReviewAll:
return targetScope == string(VisibilityInternal) || targetScope == string(VisibilityExternal)
default:
return false
}
}
// Describe 给界面/运维看的一句话说明。
func (policy AutoReviewPolicy) Describe() string {
switch policy {
case AutoReviewOff:
return "全部人工审核"
case AutoReviewAll:
return "对内对外都自动批准(验收通过即批准)"
case AutoReviewInternal:
return "对内自动批准,对外仍需人工"
default:
return string(policy)
}
}
+47
View File
@@ -0,0 +1,47 @@
package governance
import "testing"
func TestParseAutoReviewPolicy(t *testing.T) {
for _, testCase := range []struct {
input string
want AutoReviewPolicy
wantErr bool
}{
{"", AutoReviewInternal, false},
{"internal", AutoReviewInternal, false},
{" INTERNAL ", AutoReviewInternal, false},
{"off", AutoReviewOff, false},
{"all", AutoReviewAll, false},
{"sometimes", "", true},
} {
got, err := ParseAutoReviewPolicy(testCase.input)
if testCase.wantErr {
if err == nil {
t.Fatalf("ParseAutoReviewPolicy(%q) = %q, want error", testCase.input, got)
}
continue
}
if err != nil || got != testCase.want {
t.Fatalf("ParseAutoReviewPolicy(%q) = %q error=%v, want %q", testCase.input, got, err, testCase.want)
}
}
}
func TestAutoReviewPolicyAllows(t *testing.T) {
// 认不出的目标范围一律不自动批准(fail-closed)。
for _, targetScope := range []string{"", "both", "blocked", "unknown"} {
if AutoReviewAll.Allows(targetScope) {
t.Fatalf("scope %q must not be auto-approved", targetScope)
}
}
if !AutoReviewInternal.Allows("internal") || AutoReviewInternal.Allows("external") {
t.Fatal("internal policy must allow only internal")
}
if !AutoReviewAll.Allows("internal") || !AutoReviewAll.Allows("external") {
t.Fatal("all policy must allow both scopes")
}
if AutoReviewOff.Allows("internal") || AutoReviewOff.Allows("external") {
t.Fatal("off policy must allow nothing")
}
}
+17 -11
View File
@@ -111,16 +111,18 @@ type Config struct {
// enumerates the production-side bases the operator can bind.
// BackupSchedule 是「系统设置 → 存储与备份」的计划存储;BackupHost 负责在目标库
// 所在主机上读回/下发计划并触发一次整库备份(未接线时页面降级展示)。
BackupSchedule BackupScheduleStore
BackupHost BackupHost
BackupRuns *BackupRunTracker
ProductionBindings ProductionBindingStore
ProductionKnowledgeBases ProductionKnowledgeBaseLister
ProductionWeKnoraBaseURL string
ServiceTargetVerifier ServiceTargetVerifier
Now func() time.Time
RequireWeKnoraReady bool
ProductionReleaseRequestsEnabled bool
BackupSchedule BackupScheduleStore
BackupHost BackupHost
BackupRuns *BackupRunTracker
ProductionBindings ProductionBindingStore
ProductionKnowledgeBases ProductionKnowledgeBaseLister
ProductionWeKnoraBaseURL string
ServiceTargetVerifier ServiceTargetVerifier
Now func() time.Time
RequireWeKnoraReady bool
ProductionReleaseRequestsEnabled bool
// TestAutoReviewPolicy 只用于展示:让运维在界面上看到"现在自动批准到什么程度"。
TestAutoReviewPolicy string
ProductionBackupRestoreVerified bool
ProductionReleaseAuthorizerRef string
ProductionReleaseAuthorizationToken string
@@ -439,9 +441,10 @@ func NewHandler(config Config) (http.Handler, error) {
getReleaseExecution(w, r, config.Store)
})
mux.HandleFunc("GET /api/v1/release-capabilities", func(w http.ResponseWriter, _ *http.Request) {
writeJSON(w, http.StatusOK, map[string]any{"data": map[string]bool{
writeJSON(w, http.StatusOK, map[string]any{"data": map[string]any{
"production_release_requests_enabled": config.ProductionReleaseRequestsEnabled,
"production_backup_restore_verified": config.ProductionBackupRestoreVerified,
"test_auto_review_policy": config.TestAutoReviewPolicy,
}})
})
mux.HandleFunc("GET /api/v1/test-publications", func(w http.ResponseWriter, r *http.Request) {
@@ -1525,6 +1528,9 @@ func createReleaseBatch(w http.ResponseWriter, r *http.Request, config Config) {
writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": "release batch contains ineligible publications"})
case errors.Is(err, postgresstore.ErrReleaseChangeSetUnconfirmed):
writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": "release change set must be confirmed and cover every requested publication"})
case errors.Is(err, postgresstore.ErrReleaseChangeSetEmpty):
// 建批时冻结依赖当前实时计划;计划为空就没得冻。
writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": "current release plan has no releasable item"})
case err != nil:
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "could not create release batch"})
default:
@@ -0,0 +1,79 @@
package postgres
import (
"context"
"errors"
"os"
"testing"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"knowledge-governance/internal/governance"
)
// 系统自动批准只能写"第一条"审核:人工一旦表过态,机器不得用一条更晚的 approved
// 把人工结论翻回去(重跑验收时尤其危险)。人工审核不受限,随时可再审。
func TestAutoReviewNeverOverridesHumanDecisions(t *testing.T) {
databaseURL := isolatedIntegrationDatabaseURL(t, os.Getenv("TEST_DATABASE_URL"))
if databaseURL == "" {
t.Skip("TEST_DATABASE_URL is not set")
}
ctx := context.Background()
pool, err := pgxpool.New(ctx, databaseURL)
if err != nil {
t.Fatal(err)
}
defer pool.Close()
if err := ApplyMigrations(ctx, pool); err != nil {
t.Fatal(err)
}
store := NewStore(pool)
now := time.Date(2026, 10, 10, 12, 0, 0, 0, time.UTC)
if _, err := pool.Exec(ctx, `INSERT INTO source_connections (id, source_type, name) VALUES ('conn-manual', 'manual', 'Manual')`); err != nil {
t.Fatal(err)
}
insertReviewFixture(t, ctx, pool, 10, "tp-auto-first", now)
insertReviewFixture(t, ctx, pool, 11, "tp-auto-rejected", now)
// 还没有任何审核:系统可以写第一条。
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-auto-first", Decision: governance.ReviewApproved,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "system:auto",
DecisionCode: "approved_for_release", Now: now.Add(time.Minute),
}); err != nil {
t.Fatalf("first auto review must be allowed: %v", err)
}
// 人工先驳回:系统再也不能自动批准这一条。
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-auto-rejected", Decision: governance.ReviewRejected,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "admin",
DecisionCode: "needs_correction", Now: now.Add(time.Minute),
}); err != nil {
t.Fatalf("human rejection must succeed: %v", err)
}
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-auto-rejected", Decision: governance.ReviewApproved,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "system:auto",
DecisionCode: "approved_for_release", Now: now.Add(2 * time.Minute),
}); !errors.Is(err, ErrPublicationReviewNotEligible) {
t.Fatalf("auto review over a human decision error=%v, want ErrPublicationReviewNotEligible", err)
}
var decision, reviewer string
if err := pool.QueryRow(ctx, `SELECT decision, reviewer_ref FROM publication_reviews WHERE publication_id='tp-auto-rejected' ORDER BY created_at DESC, id DESC LIMIT 1`).Scan(&decision, &reviewer); err != nil {
t.Fatal(err)
}
if decision != "rejected" || reviewer != "admin" {
t.Fatalf("latest review = %q by %q, want rejected by admin", decision, reviewer)
}
// 人工仍可再审(例如改判为批准)。
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-auto-rejected", Decision: governance.ReviewApproved,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "admin",
DecisionCode: "approved_for_release", Now: now.Add(3 * time.Minute),
}); err != nil {
t.Fatalf("human re-review must still be allowed: %v", err)
}
}
@@ -0,0 +1,118 @@
package postgres
import (
"context"
"errors"
"os"
"testing"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"knowledge-governance/internal/governance"
)
// P0-1「建批时冻结」:操作员不必先"生成新版本 + 确认冻结",清单在建批那一刻固化。
// 这里固化的三件事:批一定绑定一份已确认版本;同一份计划复用同一版本;冻结之后不可变。
func TestBindTimeFreezeCreatesAndReusesConfirmedManifest(t *testing.T) {
databaseURL := isolatedIntegrationDatabaseURL(t, os.Getenv("TEST_DATABASE_URL"))
if databaseURL == "" {
t.Skip("TEST_DATABASE_URL is not set")
}
ctx := context.Background()
pool, err := pgxpool.New(ctx, databaseURL)
if err != nil {
t.Fatal(err)
}
defer pool.Close()
if err := ApplyMigrations(ctx, pool); err != nil {
t.Fatal(err)
}
store := NewStore(pool)
now := time.Date(2026, 10, 10, 14, 0, 0, 0, time.UTC)
if _, err := pool.Exec(ctx, `INSERT INTO source_connections (id, source_type, name) VALUES ('conn-manual', 'manual', 'Manual')`); err != nil {
t.Fatal(err)
}
insertReviewFixture(t, ctx, pool, 12, "tp-p01-a", now)
insertReviewFixture(t, ctx, pool, 13, "tp-p01-b", now)
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-p01-a", Decision: governance.ReviewApproved,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1",
DecisionCode: "approved_for_release", Now: now.Add(time.Minute),
}); err != nil {
t.Fatal(err)
}
// 建批不带版本 id:服务端自己冻结一份已确认版本并绑定。
first, err := store.CreateReleaseBatch(ctx, governance.CreateReleaseBatchRequest{
Name: "P0-1 自动冻结", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-p01-a"}, Now: now.Add(2 * time.Minute),
})
if err != nil {
t.Fatalf("bind-time freeze must let the batch through: %v", err)
}
if first.ReleaseChangeSetID == "" {
t.Fatal("batch must be bound to a frozen release change set")
}
var state, manifest string
var itemCount int
if err := pool.QueryRow(ctx, `SELECT state, manifest_sha256, item_count FROM release_change_sets WHERE id=$1`, first.ReleaseChangeSetID).Scan(&state, &manifest, &itemCount); err != nil {
t.Fatal(err)
}
if state != "confirmed" {
t.Fatalf("frozen set state = %q, want confirmed", state)
}
if len(manifest) != 64 {
t.Fatalf("manifest digest = %q, want 64 hex chars", manifest)
}
var covered bool
var canRelease bool
if err := pool.QueryRow(ctx, `SELECT TRUE, can_release FROM release_change_set_items WHERE change_set_id=$1 AND publication_id='tp-p01-a'`, first.ReleaseChangeSetID).Scan(&covered, &canRelease); err != nil {
t.Fatalf("frozen manifest must cover the requested publication: %v", err)
}
if !canRelease {
t.Fatal("covered item must be marked releasable")
}
// 计划没变 → 复用同一份版本,不堆版本。
second, err := store.CreateReleaseBatch(ctx, governance.CreateReleaseBatchRequest{
Name: "P0-1 自动冻结 2", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-p01-a"}, Now: now.Add(3 * time.Minute),
})
if err != nil {
t.Fatal(err)
}
if second.ReleaseChangeSetID != first.ReleaseChangeSetID {
t.Fatalf("unchanged plan must reuse the frozen version: %q vs %q", second.ReleaseChangeSetID, first.ReleaseChangeSetID)
}
// 冻结之后不可变:之后又批准一条,也不改变已建批次绑定的那份清单。
if _, err := store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: "tp-p01-b", Decision: governance.ReviewApproved,
DecidedVisibility: governance.VisibilityInternal, ReviewerRef: "engineer-1",
DecisionCode: "approved_for_release", Now: now.Add(4 * time.Minute),
}); err != nil {
t.Fatal(err)
}
var stateAfter, manifestAfter string
var itemCountAfter int
if err := pool.QueryRow(ctx, `SELECT state, manifest_sha256, item_count FROM release_change_sets WHERE id=$1`, first.ReleaseChangeSetID).Scan(&stateAfter, &manifestAfter, &itemCountAfter); err != nil {
t.Fatal(err)
}
if stateAfter != state || manifestAfter != manifest || itemCountAfter != itemCount {
t.Fatalf("frozen manifest changed after later approvals: %q/%q/%d", stateAfter, manifestAfter, itemCountAfter)
}
// 没有审核结论的条目依然进不了批次(放到新冻结里也不行)。
if _, err := store.CreateReleaseBatch(ctx, governance.CreateReleaseBatchRequest{
Name: "P0-1 未审核条目", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-p01-c"}, Now: now.Add(5 * time.Minute),
}); err == nil {
t.Fatal("an unknown publication must not be accepted into a batch")
}
// 请求的动作与计划不符(把"新增"当"删除"发)→ 门禁不通过,且必须是可读的错误码。
_, err = store.CreateReleaseBatch(ctx, governance.CreateReleaseBatchRequest{
Name: "P0-1 动作不符", CreatedBy: "engineer-1", DeletePublicationIDs: []string{"tp-p01-a"}, Now: now.Add(6 * time.Minute),
})
if !errors.Is(err, ErrReleaseBatchNotEligible) {
t.Fatalf("action mismatch error=%v, want ErrReleaseBatchNotEligible", err)
}
}
@@ -77,7 +77,16 @@ FROM release_executions e JOIN release_item_executions i ON i.release_execution_
if state != "completed" {
t.Fatalf("unbound success must stay completed, got %q", state)
}
if len(sealed) != 64 || sealed != ComputeReleaseExecutionManifest("publish", "", []string{publicationID + "|" + bundleSHA + "|" + revision}) {
// P0-1 之后建批必然绑定一份已冻结版本,执行摘要因此包含该版本清单的摘要。
var frozenManifest string
if err := pool.QueryRow(ctx, `SELECT change_set.manifest_sha256
FROM release_executions execution
JOIN release_batches batch ON batch.id = execution.release_batch_id
JOIN release_change_sets change_set ON change_set.id = batch.release_change_set_id
WHERE execution.id=$1`, executionID).Scan(&frozenManifest); err != nil {
t.Fatal(err)
}
if len(sealed) != 64 || sealed != ComputeReleaseExecutionManifest("publish", frozenManifest, []string{publicationID + "|" + bundleSHA + "|" + revision}) {
t.Fatalf("manifest not sealed/deterministic: %q", sealed)
}
// Re-seal must be a no-op (immutable once set).
@@ -15,6 +15,40 @@ import (
const releaseGatePolicyVersion = "release-gate-v1"
// ensureFrozenChangeSetForPlan 把当前实时计划冻结为一份已确认的不可变版本,返回其 id。
// 复用规则:与当前计划摘要完全一致的最近版本(planned 或 confirmed)直接复用并确认
// (对已确认版本 Confirm 是幂等重放),因此同一份计划不会每个批次都堆一版;计划变了才新建。
func (s *Store) ensureFrozenChangeSetForPlan(ctx context.Context, request governance.CreateReleaseBatchRequest) (string, error) {
plan, err := s.ListReleasePlan(ctx)
if err != nil {
return "", err
}
if len(plan.Items) == 0 {
return "", ErrReleaseChangeSetEmpty
}
manifest := ComputeReleaseChangeSetManifest(ChangeSetItemsFromPlan(plan.Items))
existing, err := s.findReusableByManifest(ctx, manifest)
switch {
case err == nil:
confirmed, confirmErr := s.ConfirmReleaseChangeSet(ctx, governance.ConfirmReleaseChangeSetRequest{ChangeSetID: existing.ID, ConfirmedBy: request.CreatedBy, Now: request.Now})
if confirmErr != nil {
return "", confirmErr
}
return confirmed.ID, nil
case !errors.Is(err, pgx.ErrNoRows):
return "", err
}
generated, err := s.GenerateReleaseChangeSet(ctx, governance.GenerateReleaseChangeSetRequest{Name: "批次冻结 · " + request.Name, CreatedBy: request.CreatedBy, Now: request.Now})
if err != nil {
return "", err
}
confirmed, err := s.ConfirmReleaseChangeSet(ctx, governance.ConfirmReleaseChangeSetRequest{ChangeSetID: generated.ID, ConfirmedBy: request.CreatedBy, Now: request.Now})
if err != nil {
return "", err
}
return confirmed.ID, nil
}
var (
ErrInvalidReleaseBatch = errors.New("invalid release batch")
ErrInvalidReleaseBatchFilter = errors.New("invalid release batch filter")
@@ -300,6 +334,17 @@ func (s *Store) CreateReleaseBatch(ctx context.Context, request governance.Creat
if !validCreateReleaseBatch(request) {
return governance.ReleaseBatch{}, ErrInvalidReleaseBatch
}
if strings.TrimSpace(request.ReleaseChangeSetID) == "" {
// P0-1「建批时冻结」:操作员不再需要先"生成新版本 + 确认冻结"。
// 冻结发生在"这一批要发什么"已经确定的时刻——建批这一下;建立之后清单不可变,
// 来源刷新与后续批准都不会改变它(回滚、审计都按它走)。语义与手工冻结完全一致,
// 只是把"按固化键的人"从操作员换成了建批动作本身。
frozenID, err := s.ensureFrozenChangeSetForPlan(ctx, request)
if err != nil {
return governance.ReleaseBatch{}, err
}
request.ReleaseChangeSetID = frozenID
}
batchID, err := newOpaqueID("rb-")
if err != nil {
return governance.ReleaseBatch{}, err
@@ -16,8 +16,10 @@ import (
func TestCreateReleaseBatchAtomicallyLocksOnlyApprovedCurrentItems(t *testing.T) {
now := time.Date(2026, 9, 6, 9, 0, 0, 0, time.UTC)
db := &recordingDB{row: releaseBatchRow{id: "rb-safe", name: "Synthetic batch", state: "draft", policy: "release-gate-v1", createdBy: "engineer-1", itemCount: 3, createdAt: now}}
// 显式传入已确认版本:这个用例检查的是建批 SQL 的门禁条件,桩 db 不提供实时计划查询;
// "不带版本 id → 服务端自动冻结"的路径由 bind_time_freeze_integration_test.go 用真库覆盖。
batch, err := NewStore(db).CreateReleaseBatch(context.Background(), governance.CreateReleaseBatchRequest{
Name: "Synthetic batch", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-a", "tp-b"}, DeletePublicationIDs: []string{"tp-c"}, Now: now,
Name: "Synthetic batch", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-a", "tp-b"}, DeletePublicationIDs: []string{"tp-c"}, ReleaseChangeSetID: "rcs-safe", Now: now,
})
if err != nil {
t.Fatalf("CreateReleaseBatch() error = %v", err)
@@ -58,13 +60,15 @@ func TestCreateReleaseBatchRejectsInvalidOrDuplicateInput(t *testing.T) {
}
}
func TestCreateReleaseBatchReturnsNotEligibleWhenAnyItemFailsGate(t *testing.T) {
// 桩 db 查不到"已确认版本",建批必须拒绝——这条守卫是"批次只能绑定已确认清单"的入口。
// 「门禁不通过 → ErrReleaseBatchNotEligible」的映射由 bind_time_freeze_integration_test.go 用真库钉住。
func TestCreateReleaseBatchRejectsUnconfirmedChangeSet(t *testing.T) {
db := &recordingDB{row: sourceScanErrorRow{err: pgx.ErrNoRows}}
_, err := NewStore(db).CreateReleaseBatch(context.Background(), governance.CreateReleaseBatchRequest{
Name: "Batch", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-a"}, Now: time.Now(),
Name: "Batch", CreatedBy: "engineer-1", PublicationIDs: []string{"tp-a"}, ReleaseChangeSetID: "rcs-safe", Now: time.Now(),
})
if !errors.Is(err, ErrReleaseBatchNotEligible) {
t.Fatalf("error=%v, want ErrReleaseBatchNotEligible", err)
if !errors.Is(err, ErrReleaseChangeSetUnconfirmed) {
t.Fatalf("error=%v, want ErrReleaseChangeSetUnconfirmed", err)
}
}
@@ -66,6 +66,16 @@ func ComputeReleaseChangeSetManifest(items []governance.ReleaseChangeSetItem) st
return hex.EncodeToString(digest[:])
}
// ChangeSetItemsFromPlan 把实时计划的条目映射成清单项。生成版本与"建批时冻结"共用它,
// 两处必须算出字节相同的摘要,否则"同一份计划复用同一版本"的判断永远不命中。
func ChangeSetItemsFromPlan(planItems []governance.ReleasePlanItem) []governance.ReleaseChangeSetItem {
items := make([]governance.ReleaseChangeSetItem, 0, len(planItems))
for index, planItem := range planItems {
items = append(items, governance.ReleaseChangeSetItem{Seq: index + 1, PublicationID: planItem.PublicationID, Title: planItem.Title, TargetScope: planItem.TargetScope, Action: planItem.Action, TestState: planItem.TestState, ProductionState: planItem.ProductionState, CanRelease: planItem.CanRelease, Blocker: planItem.Blocker})
}
return items
}
// GenerateReleaseChangeSet freezes the current live plan into an immutable
// versioned set. Repeated generation with an identical plan reuses the latest
// PLANNED set (dedup), so concurrent generation cannot create duplicates.
@@ -78,10 +88,7 @@ func (s *Store) GenerateReleaseChangeSet(ctx context.Context, request governance
if err != nil {
return governance.ReleaseChangeSet{}, err
}
items := make([]governance.ReleaseChangeSetItem, 0, len(plan.Items))
for index, planItem := range plan.Items {
items = append(items, governance.ReleaseChangeSetItem{Seq: index + 1, PublicationID: planItem.PublicationID, Title: planItem.Title, TargetScope: planItem.TargetScope, Action: planItem.Action, TestState: planItem.TestState, ProductionState: planItem.ProductionState, CanRelease: planItem.CanRelease, Blocker: planItem.Blocker})
}
items := ChangeSetItemsFromPlan(plan.Items)
if len(items) == 0 {
return governance.ReleaseChangeSet{}, ErrReleaseChangeSetEmpty
}
@@ -191,6 +198,12 @@ func (s *Store) findPlannedByManifest(ctx context.Context, manifest string) (gov
return scanReleaseChangeSet(s.db.QueryRow(ctx, `SELECT `+releaseChangeSetColumns+` FROM release_change_sets WHERE manifest_sha256=$1 AND state='planned' ORDER BY number DESC LIMIT 1`, manifest))
}
// findReusableByManifest 找与当前计划摘要一致的最近版本(planned 或 confirmed)。
// 建批时冻结用它复用:同一份计划不必因为每个批次都新建一版。
func (s *Store) findReusableByManifest(ctx context.Context, manifest string) (governance.ReleaseChangeSet, error) {
return scanReleaseChangeSet(s.db.QueryRow(ctx, `SELECT `+releaseChangeSetColumns+` FROM release_change_sets WHERE manifest_sha256=$1 AND state IN ('planned','confirmed') ORDER BY number DESC LIMIT 1`, manifest))
}
// ConfirmReleaseChangeSet freezes a planned set for batching. Re-confirming an
// already-confirmed set replays the stored confirmation (immutability).
func (s *Store) ConfirmReleaseChangeSet(ctx context.Context, request governance.ConfirmReleaseChangeSetRequest) (governance.ReleaseChangeSet, error) {
+6
View File
@@ -122,6 +122,12 @@ SELECT $1::varchar, publication_id, $3::varchar, $4::varchar, $5::varchar, $6::v
FROM candidates
WHERE publication_id = $2::varchar
AND ($3::varchar = 'rejected' OR gate_status = 'ready')
-- 系统自动批准(reviewer_ref='system:auto')只允许写"第一条"审核:人工一旦表过态,
-- 机器不得再用一条更晚的 approved 把人工结论静默翻回去(重跑验收时尤其危险)。
-- 人工审核不受此限,随时可再审。
AND ($5::varchar <> 'system:auto' OR NOT EXISTS (
SELECT 1 FROM publication_reviews existing
WHERE existing.publication_id = candidates.publication_id))
ON CONFLICT (
publication_id, acceptance_run_id, publication_updated_at,
reviewer_ref, decision, decided_visibility, decision_code
@@ -58,6 +58,9 @@ type PublicationForValidation struct {
ID string
TestKBID string
KnowledgeID string
// TargetScope 决定这条知识发到哪个生产库(对内/对外)。自动批准策略依赖它:
// 默认只自动批准"对内","对外"仍要人工。
TargetScope string
}
type LegacyVerificationCandidate struct {
@@ -94,7 +97,7 @@ WHERE id = $1
`
const loadPublicationForValidationSQL = `
SELECT id, test_kb_id, knowledge_id
SELECT id, test_kb_id, knowledge_id, target_scope
FROM test_publications
WHERE id = $1
AND ingest_state = 'uploaded'
@@ -443,6 +446,7 @@ func (s *Store) LoadPublicationForValidation(ctx context.Context, publicationID
&publication.ID,
&publication.TestKBID,
&publication.KnowledgeID,
&publication.TargetScope,
)
if errors.Is(err, pgx.ErrNoRows) {
return PublicationForValidation{}, ErrPublicationStateConflict
+55 -7
View File
@@ -6,6 +6,7 @@ import (
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"time"
"knowledge-governance/internal/governance"
@@ -23,6 +24,9 @@ var (
type ValidateStore interface {
LoadPublicationForValidation(context.Context, string) (postgresstore.PublicationForValidation, error)
AppendAcceptanceResult(context.Context, governance.AcceptanceResult) error
// ReviewPublication 复用人工审核同一条写入路径:同一套合法性校验与"最新验收轮次"绑定,
// 自动批准不另开一条 SQL,避免两套口径。
ReviewPublication(context.Context, governance.ReviewPublicationRequest) (governance.PublicationReview, error)
}
type ValidateClient interface {
@@ -35,17 +39,26 @@ type ValidateHandlerConfig struct {
Client ValidateClient
RunID string
PolicyVersion string
Now func() time.Time
// AutoReviewPolicy:验收通过后是否由系统写入批准。零值按"仅对内"处理(与 env 默认一致)。
AutoReviewPolicy governance.AutoReviewPolicy
// Report 只用于记录自动批准自身的失败:它绝不能把验收判成失败。
Report func(error)
Now func() time.Time
}
type ValidateHandler struct {
store ValidateStore
client ValidateClient
runID string
policyVersion string
now func() time.Time
store ValidateStore
client ValidateClient
runID string
policyVersion string
autoReviewPolicy governance.AutoReviewPolicy
report func(error)
now func() time.Time
}
// autoReviewerRef:自动批准在审计里必须一眼可辨,绝不冒用某个人的身份。
const autoReviewerRef = "system:auto"
type validatePayload struct {
PublicationID string `json:"publication_id"`
}
@@ -60,9 +73,16 @@ func NewValidateHandler(config ValidateHandlerConfig) (*ValidateHandler, error)
if config.Now == nil {
config.Now = time.Now
}
if config.AutoReviewPolicy == "" {
config.AutoReviewPolicy = governance.AutoReviewInternal
}
if config.Report == nil {
config.Report = func(error) {}
}
return &ValidateHandler{
store: config.Store, client: config.Client, runID: config.RunID,
policyVersion: config.PolicyVersion, now: config.Now,
policyVersion: config.PolicyVersion, autoReviewPolicy: config.AutoReviewPolicy,
report: config.Report, now: config.Now,
}, nil
}
@@ -104,9 +124,37 @@ func (handler *ValidateHandler) Handle(ctx context.Context, job jobs.Job) error
if err := handler.append(ctx, publication.ID, runID, "retrieval_hit", governance.AcceptanceManualRequired, json.RawMessage(`{"reason":"thresholds_unresolved"}`), now); err != nil {
return err
}
handler.autoApprove(ctx, publication, runID, knowledgeState, chunksState, now)
return nil
}
// autoApprove:验收通过的知识由系统写入批准,替代"每份文档点一次批准"。
//
// 触发条件与发布门槛同口径:knowledge_exists / chunks_present 必须 passed
// (retrieval_hit 固定为 manual_required,发布门槛同样接受)。
// 自动批准自身的任何失败都不影响验收结论——只上报,不返回错误。
func (handler *ValidateHandler) autoApprove(ctx context.Context, publication postgresstore.PublicationForValidation, runID string, knowledgeState, chunksState governance.AcceptanceState, now time.Time) {
if !handler.autoReviewPolicy.Allows(publication.TargetScope) {
return
}
if knowledgeState != governance.AcceptancePassed || chunksState != governance.AcceptancePassed {
return
}
_, err := handler.store.ReviewPublication(ctx, governance.ReviewPublicationRequest{
PublicationID: publication.ID,
Decision: governance.ReviewApproved,
DecidedVisibility: governance.Visibility(publication.TargetScope),
ReviewerRef: autoReviewerRef,
DecisionCode: "approved_for_release",
Now: now,
})
if err == nil || errors.Is(err, postgresstore.ErrPublicationReviewNotEligible) {
// 已经有人审过(或不满足审核前置):不覆盖人工结论。
return
}
handler.report(fmt.Errorf("auto review %s: %w", publication.ID, err))
}
func (handler *ValidateHandler) append(ctx context.Context, publicationID, runID, checkType string, state governance.AcceptanceState, evidence json.RawMessage, observedAt time.Time) error {
result := governance.AcceptanceResult{
ID: acceptanceResultID(publicationID, runID, checkType),
@@ -2,6 +2,7 @@ package testweknora
import (
"context"
"errors"
"testing"
"time"
@@ -89,6 +90,8 @@ func TestValidateHandlerFailsChecksWithoutAborting(t *testing.T) {
type validateStoreStub struct {
publication postgresstore.PublicationForValidation
appended []governance.AcceptanceResult
reviews []governance.ReviewPublicationRequest
reviewErr error
}
func (store *validateStoreStub) LoadPublicationForValidation(context.Context, string) (postgresstore.PublicationForValidation, error) {
@@ -100,6 +103,14 @@ func (store *validateStoreStub) AppendAcceptanceResult(_ context.Context, result
return nil
}
func (store *validateStoreStub) ReviewPublication(_ context.Context, request governance.ReviewPublicationRequest) (governance.PublicationReview, error) {
if store.reviewErr != nil {
return governance.PublicationReview{}, store.reviewErr
}
store.reviews = append(store.reviews, request)
return governance.PublicationReview{ID: "rv-auto", PublicationID: request.PublicationID}, nil
}
type validateClientStub struct {
knowledge weknora.Knowledge
chunkTotal int64
@@ -116,3 +127,85 @@ func (client *validateClientStub) ListChunks(context.Context, string, int, int,
}
return chunks, client.chunkTotal, nil
}
// 自动批准:验收通过的知识由系统写入批准,替代"每份文档人工点一次批准"。
// 关键边界:对外不自动、策略可关、验收没过不批、自动批准自己失败也绝不把验收判成失败。
func TestValidateHandlerAutoApprovesVerifiedInternalPublications(t *testing.T) {
run := func(t *testing.T, scope string, policy governance.AutoReviewPolicy, knowledgeBase, knowledgeID string, reviewErr error) (*validateStoreStub, error) {
t.Helper()
client := &validateClientStub{
knowledge: weknora.Knowledge{ID: knowledgeID, KnowledgeBaseID: knowledgeBase},
chunkTotal: 3,
}
store := &validateStoreStub{
publication: postgresstore.PublicationForValidation{ID: "publication-1", TestKBID: "kb-1", KnowledgeID: "knowledge-1", TargetScope: scope},
reviewErr: reviewErr,
}
now := time.Date(2026, time.October, 10, 8, 0, 0, 0, time.UTC)
handler, err := NewValidateHandler(ValidateHandlerConfig{
Store: store, Client: client, RunID: "run-1", PolicyVersion: "structural-v1",
AutoReviewPolicy: policy, Now: func() time.Time { return now },
})
if err != nil {
t.Fatal(err)
}
return store, handler.Handle(context.Background(), jobs.Job{ID: "job-1", Payload: []byte(`{"publication_id":"publication-1"}`)})
}
store, err := run(t, "internal", governance.AutoReviewInternal, "kb-1", "knowledge-1", nil)
if err != nil {
t.Fatalf("Handle() error = %v", err)
}
if len(store.reviews) != 1 {
t.Fatalf("auto reviews = %d, want 1", len(store.reviews))
}
review := store.reviews[0]
if review.ReviewerRef != "system:auto" || review.Decision != governance.ReviewApproved || review.DecidedVisibility != governance.VisibilityInternal || review.DecisionCode != "approved_for_release" {
t.Fatalf("auto review = %#v", review)
}
if review.Now.IsZero() {
t.Fatalf("auto review must carry the observation time")
}
// 对外:默认不自动批准。
external, err := run(t, "external", governance.AutoReviewInternal, "kb-1", "knowledge-1", nil)
if err != nil || len(external.reviews) != 0 {
t.Fatalf("external auto reviews = %d error = %v", len(external.reviews), err)
}
// 策略关闭。
off, err := run(t, "internal", governance.AutoReviewOff, "kb-1", "knowledge-1", nil)
if err != nil || len(off.reviews) != 0 {
t.Fatalf("off auto reviews = %d error = %v", len(off.reviews), err)
}
// 验收没过(知识存在性校验失败):不批准。
failed, err := run(t, "internal", governance.AutoReviewInternal, "kb-other", "knowledge-1", nil)
if err != nil || len(failed.reviews) != 0 {
t.Fatalf("failed-acceptance auto reviews = %d error = %v", len(failed.reviews), err)
}
// 自动批准自己失败(例如已被人工审过)不能让验收失败。
conflicted, err := run(t, "internal", governance.AutoReviewInternal, "kb-1", "knowledge-1", postgresstore.ErrPublicationReviewNotEligible)
if err != nil {
t.Fatalf("review-not-eligible must not fail validation: %v", err)
}
if len(conflicted.reviews) != 0 || len(conflicted.appended) != 3 {
t.Fatalf("conflicted reviews = %d appended = %d", len(conflicted.reviews), len(conflicted.appended))
}
// 其他错误也只是上报,不影响验收结论。
reported := 0
client := &validateClientStub{knowledge: weknora.Knowledge{ID: "knowledge-1", KnowledgeBaseID: "kb-1"}, chunkTotal: 3}
store2 := &validateStoreStub{publication: postgresstore.PublicationForValidation{ID: "publication-1", TestKBID: "kb-1", KnowledgeID: "knowledge-1", TargetScope: "internal"}, reviewErr: errors.New("boom")}
handler, err := NewValidateHandler(ValidateHandlerConfig{
Store: store2, Client: client, RunID: "run-1", PolicyVersion: "structural-v1",
AutoReviewPolicy: governance.AutoReviewInternal, Report: func(error) { reported++ },
Now: func() time.Time { return time.Now().UTC() },
})
if err != nil {
t.Fatal(err)
}
if err := handler.Handle(context.Background(), jobs.Job{ID: "job-2", Payload: []byte(`{"publication_id":"publication-1"}`)}); err != nil {
t.Fatalf("auto review failure must not fail validation: %v", err)
}
if reported != 1 {
t.Fatalf("reported = %d, want 1", reported)
}
}
+4 -4
View File
@@ -349,7 +349,7 @@ describe('ReleaseManagement', () => {
reviewPage={reviewPage} reviewLoading={false} reviewError={null} reviewingId={null}
batchPage={batchPage} batchDetail={batchDetail} batchLoading={false} batchError={null} mutatingBatchId={null}
onReview={vi.fn()} onReviewRefresh={vi.fn()} onCreateBatch={vi.fn()} onSealBatch={vi.fn()} onSelectBatch={vi.fn()} onBatchRefresh={vi.fn()}
releaseCapabilities={{ production_release_requests_enabled: true, production_backup_restore_verified: false }} executionPage={executionPage} executionDetail={executionDetail} executionLoading={false} executionError={null} onSelectExecution={vi.fn()} onExecutionRefresh={vi.fn()}
releaseCapabilities={{ production_release_requests_enabled: true, production_backup_restore_verified: false, test_auto_review_policy: '' }} executionPage={executionPage} executionDetail={executionDetail} executionLoading={false} executionError={null} onSelectExecution={vi.fn()} onExecutionRefresh={vi.fn()}
releasePlan={releasePlan}
selectedDeleteIDs={['tp-delete']} onToggleDelete={vi.fn()}
/>)
@@ -413,7 +413,7 @@ describe('release plan pagination (R3)', () => {
batchPage: { items: [], total: 0, limit: 20, offset: 0 } as any,
batchDetail: null, batchLoading: false, batchError: null, mutatingBatchId: null,
onReview: vi.fn(), onReviewRefresh: vi.fn(), onCreateBatch: vi.fn(), onSealBatch: vi.fn(), onSelectBatch: vi.fn(), onBatchRefresh: vi.fn(),
releaseCapabilities: { production_release_requests_enabled: false, production_backup_restore_verified: false },
releaseCapabilities: { production_release_requests_enabled: false, production_backup_restore_verified: false, test_auto_review_policy: '' },
executionPage: { items: [], total: 0, limit: 20, offset: 0 } as any,
executionDetail: null, executionLoading: false, executionError: null, onSelectExecution: vi.fn(), onExecutionRefresh: vi.fn(),
selectedDeleteIDs: [] as string[], onToggleDelete: vi.fn(),
@@ -457,7 +457,7 @@ describe('R4 rollback levels in the execution timeline', () => {
batchPage: { items: [], total: 0, limit: 20, offset: 0 } as any,
batchDetail: null, batchLoading: false, batchError: null, mutatingBatchId: null,
onReview: vi.fn(), onReviewRefresh: vi.fn(), onCreateBatch: vi.fn(), onSealBatch: vi.fn(), onSelectBatch: vi.fn(), onBatchRefresh: vi.fn(),
releaseCapabilities: { production_release_requests_enabled: true, production_backup_restore_verified: false },
releaseCapabilities: { production_release_requests_enabled: true, production_backup_restore_verified: false, test_auto_review_policy: '' },
releasePlan: { items: [], summary: { add: 0, update: 0, delete: 0, blocked: 0, unchanged: 0 } } as ReleasePlan,
executionDetail: null, executionLoading: false, executionError: null, onSelectExecution: vi.fn(), onExecutionRefresh: vi.fn(),
selectedDeleteIDs: [] as string[], onToggleDelete: vi.fn(),
@@ -494,7 +494,7 @@ describe('ReleaseManagement production actions', () => {
reviewPage={{ items: [], total: 0, limit: 20, offset: 0 }} reviewLoading={false} reviewError={null} reviewingId={null}
batchPage={batchPage} batchDetail={null} batchLoading={false} batchError={null} mutatingBatchId={null}
onReview={vi.fn()} onReviewRefresh={vi.fn()} onCreateBatch={vi.fn()} onSealBatch={vi.fn()} onSelectBatch={vi.fn()} onBatchRefresh={vi.fn()}
releaseCapabilities={{ production_release_requests_enabled: true, production_backup_restore_verified: true }}
releaseCapabilities={{ production_release_requests_enabled: true, production_backup_restore_verified: true, test_auto_review_policy: '' }}
executionPage={executionPage} executionDetail={null} executionLoading={false} executionError={null} onSelectExecution={vi.fn()} onExecutionRefresh={vi.fn()}
releasePlan={{ items: [], summary: { add: 0, update: 0, delete: 0, blocked: 0, unchanged: 0 } }}
selectedDeleteIDs={[]} onToggleDelete={vi.fn()} {...extra} />
+18 -7
View File
@@ -12,7 +12,7 @@ import { fetchSourceAssets } from './assets'
import type { LegacyStatus, SourceAssetPage } from './assets'
import { fetchJobs } from './jobs'
import type { Job, JobState } from './jobs'
import { confirmReleaseChangeSet, createReleaseBatch, fetchLatestReleaseChangeSet, fetchReleaseAuditChain, fetchReleaseBatch, fetchReleaseBatches, fetchReleaseCapabilities, fetchReleaseExecution, fetchReleaseExecutions, fetchReleasePlan, fetchReviewCandidates, generateReleaseChangeSet, productionConfirmationPhrases, reviewPublication, runProductionAction, sealReleaseBatch } from './reviewRelease'
import { confirmReleaseChangeSet, createReleaseBatch, fetchLatestReleaseChangeSet, fetchReleaseAuditChain, fetchReleaseBatch, fetchReleaseBatches, fetchReleaseCapabilities, fetchReleaseExecution, fetchReleaseExecutions, fetchReleasePlan, fetchReviewCandidates, generateReleaseChangeSet, productionConfirmationPhrases, reviewPublication, runProductionAction, sealReleaseBatch } from './reviewRelease'
import type { ProductionActionKind } from './reviewRelease'
import type { ReleaseAuditChain, ReleaseBatchDetail, ReleaseBatchPage, ReleaseCapabilities, ReleaseChangeSetDetail, ReleaseExecutionDetail, ReleaseExecutionPage, ReleasePlan, ReleasePlanItem, ReviewCandidatePage, Visibility } from './reviewRelease'
import { fetchSourceConnections, fetchSourceScanDetail, fetchSourceScans, triggerSourceScan } from './sourceConnections'
@@ -251,7 +251,7 @@ const emptyReviewPage: ReviewCandidatePage = { items: [], total: 0, limit: 20, o
const emptyBatchPage: ReleaseBatchPage = { items: [], total: 0, limit: 20, offset: 0 }
const emptyExecutionPage: ReleaseExecutionPage = { items: [], total: 0, limit: 20, offset: 0 }
const disabledReleaseCapabilities: ReleaseCapabilities = { production_release_requests_enabled: false, production_backup_restore_verified: false }
const disabledReleaseCapabilities: ReleaseCapabilities = { production_release_requests_enabled: false, production_backup_restore_verified: false, test_auto_review_policy: '' }
const emptyReleasePlan: ReleasePlan = { items: [], summary: { add: 0, update: 0, delete: 0, blocked: 0, unchanged: 0 } }
export function ModulePage({ moduleId, jobs, loading, error, onRefresh, connectionPage = emptyConnectionPage, connectionLoading = false, connectionError = null, onConnectionRefresh = () => undefined, scanningConnectionId = null, onTriggerSourceScan = () => undefined, scanPage = emptyScanPage, scanDetail = null, scanLoading = false, scanError = null, selectedScanId = null, onSelectScan = () => undefined, assetPage = emptyAssetPage, assetLoading = false, assetError = null, assetState = '', onAssetStateChange = () => undefined, onAssetPageChange = () => undefined, onAssetRefresh = () => undefined, publicationPage = emptyPublicationPage, publicationLoading = false, publicationError = null, publicationState = '', retryingId = null, onPublicationStateChange = () => undefined, onPublicationPageChange = () => undefined, onPublicationRefresh = () => undefined, onRetry = () => undefined, reviewPage = emptyReviewPage, reviewLoading = false, reviewError = null, reviewingId = null, batchPage = emptyBatchPage, batchDetail = null, batchLoading = false, batchError = null, mutatingBatchId = null, onReview = () => undefined, onReviewRefresh = () => undefined, onCreateBatch = () => undefined, onSealBatch = () => undefined, onSelectBatch = () => undefined, onBatchRefresh = () => undefined, releaseCapabilities = disabledReleaseCapabilities, releasePlan = emptyReleasePlan, releaseChangeSet = null, changeSetBusy = false, changeSetError = null, onGenerateChangeSet = () => undefined, onConfirmChangeSet = () => undefined, selectedDeleteIDs = [], onToggleDelete = () => undefined, executionPage = emptyExecutionPage, executionDetail = null, executionChain = null, executionLoading = false, executionError = null, onSelectExecution = () => undefined, onExecutionRefresh = () => undefined, pendingReleaseAction = null, releaseActionPhrase = '', releaseActionBusy = false, releaseActionError = null, releaseActionMessage = null, onStartReleaseAction = () => undefined, onReleaseActionPhrase = () => undefined, onSubmitReleaseAction = () => undefined, onCancelReleaseAction = () => undefined }: ModulePageProps) {
@@ -866,6 +866,14 @@ function releaseGuidance(props: ReleaseManagementProps, pending: number) {
}
}
// 审核策略文案:让运维一眼看到"现在自动批准到什么程度",而不是靠猜。
function autoReviewNote(policy: string): string {
if (policy === 'off') return '审核策略:全部人工审核(验收通过也不会自动批准)。'
if (policy === 'internal') return '审核策略:对内知识验收通过后由系统自动批准(记为 system:auto);对外仍需人工。'
if (policy === 'all') return '审核策略:对内对外都在验收通过后由系统自动批准;对外发布请另行把关。'
return ''
}
export function ReleaseManagement(props: ReleaseManagementProps) {
/* R3 pagination probe */
const auth = useOptionalAuth()
@@ -894,6 +902,9 @@ export function ReleaseManagement(props: ReleaseManagementProps) {
: !props.releaseCapabilities.production_backup_restore_verified
? '生产操作权限:已阻断'
: '生产操作权限:等待负责人确认'
// 建批只绑定"已确认"的版本;所选知识不在那份清单里时必定 422(今天实测的坑)。
// 就地把它变成可操作:说明原因 + 给一个"生成新版本并确认冻结"的按钮。
// P0-1 之后不再有"所选知识不在已冻结清单里"这种阻断:清单在建批那一刻才冻结。
const batchBlocker = [
selectedCount === 0 ? '请先勾选已批准或待删除的知识' : '',
props.selectedDeleteIDs.length > 0 && !deleteConfirmed ? '请确认所选删除项会停止生产检索' : '',
@@ -991,9 +1002,7 @@ export function ReleaseManagement(props: ReleaseManagementProps) {
{changeSet && changeSet.state === 'planned' ? <details className="release-changeset-items"><summary>查看冻结清单({changeSet.items.length}项)</summary><ul>{changeSet.items.map((item) => <li key={item.seq}>{`${item.seq}. ${item.title} · ${item.target_scope === 'internal' ? '对内' : '对外'} · ${frozenActionLabel(item.action)}${item.can_release ? '' : '(阻断:' + (item.blocker === 'source_unavailable' ? '来源不可用' : '测试未就绪') + ')'}`}</li>)}</ul></details> : null}
{changeSetError ? <p className="form-error">{changeSetError}</p> : null}
<div className="release-changeset-actions">
<button type="button" className="secondary-action" disabled={changeSetBusy} title="把当前实时发布计划固化为新版本(相同计划自动去重)" onClick={() => onGenerateChangeSet(batchName.trim() || `发布计划 ${new Date().toLocaleDateString('zh-CN')}`)}>生成新版本</button>
{changeSet && changeSet.state === 'planned' ? <button type="button" disabled={changeSetBusy} onClick={() => onConfirmChangeSet(changeSet.id)}>确认冻结(此后不可更改)</button> : null}
{changeSet && changeSet.state === 'confirmed' ? <small className="safe-badge">创建批次将自动绑定 v{changeSet.number} 并校验清单</small> : <small>草稿批次需先由上方“确认冻结”固定目标</small>}
{changeSet ? <small className="safe-badge">建批时自动冻结当前计划(同摘要复用同一版本 v{changeSet.number}),无需手动确认冻结</small> : <small>建批时会自动冻结当前发布计划</small>}
</div>
</div>
})()}
@@ -1007,7 +1016,7 @@ export function ReleaseManagement(props: ReleaseManagementProps) {
</section>
<section className="panel review-panel" id="review-actions">
<div className="panel-heading release-toolbar">
<div><h2>第 3 步:审核要发布的知识</h2><p>先确认测试结果和对内/对外范围,再批准或驳回。批准后才能勾选加入批次。</p></div>
<div><h2>第 3 步:审核要发布的知识</h2><p>先确认测试结果和对内/对外范围,再批准或驳回。批准后才能勾选加入批次。</p>{autoReviewNote(props.releaseCapabilities.test_auto_review_policy) ? <p className="tiny" role="note">{autoReviewNote(props.releaseCapabilities.test_auto_review_policy)}</p> : null}</div>
</div>
{batchBlocker ? <div className="button-reason" role="note"><strong>{`为什么按钮不能点:${batchBlocker}`}</strong></div> : null}
<div className="review-decision-guide" aria-label="审核判断标准">
@@ -1389,7 +1398,9 @@ export default function App() {
setMutatingBatchId('creating')
setBatchError(null)
try {
const batch = await createReleaseBatch(name, publicationIDs, deletePublicationIDs, releaseChangeSet?.state === 'confirmed' ? releaseChangeSet.id : '')
// 不传版本 id:服务端在"建批这一下"冻结当前计划(同摘要复用同一版本),
// 操作员因此不必先「生成新版本」再「确认冻结」。
const batch = await createReleaseBatch(name, publicationIDs, deletePublicationIDs, '')
setSelectedDeleteIDs([])
await loadBatches()
setBatchDetail(await fetchReleaseBatch(batch.id))
+13 -1
View File
@@ -116,7 +116,7 @@ describe('release execution audit parsing', () => {
expect(page.items[0]).not.toHaveProperty('manifest_sha256')
const detail = parseReleaseExecutionDetailResponse({ data: { ...execution, items: [{ publication_id: 'tp-safe', title: 'Synthetic', action: 'delete', state: 'verified', previous_production_revision: 'prod-v0', production_revision: 'absent', error_code: '', created_at: '2026-09-06T10:00:00Z', completed_at: '2026-09-06T10:02:00Z', target_knowledge_base_id: 'kb-target-1', knowledge_id: 'must-drop' }] } })
expect(detail.items[0]).toEqual({ publication_id: 'tp-safe', title: 'Synthetic', action: 'delete', state: 'verified', previous_production_revision: 'prod-v0', production_revision: 'absent', error_code: '', created_at: '2026-09-06T10:00:00Z', completed_at: '2026-09-06T10:02:00Z', target_knowledge_base_id: 'kb-target-1' })
expect(parseReleaseCapabilitiesResponse({ data: { production_release_requests_enabled: true, production_backup_restore_verified: false, secret: 'drop' } })).toEqual({ production_release_requests_enabled: true, production_backup_restore_verified: false })
expect(parseReleaseCapabilitiesResponse({ data: { production_release_requests_enabled: true, production_backup_restore_verified: false, secret: 'drop' } })).toEqual({ production_release_requests_enabled: true, production_backup_restore_verified: false, test_auto_review_policy: '' })
})
it('rejects a release item execution the API forgot to describe', () => {
@@ -243,3 +243,15 @@ describe('建批失败时把服务端原因带出来', () => {
await expect(createReleaseBatch('验收12', ['tp-x'], [], '')).rejects.toThrow('could not create release batch')
})
})
describe('审核策略的只读展示', () => {
it('服务端返回策略时解析出来', () => {
const parsed = parseReleaseCapabilitiesResponse({ data: { production_release_requests_enabled: true, production_backup_restore_verified: true, test_auto_review_policy: 'internal' } })
expect(parsed.test_auto_review_policy).toBe('internal')
})
it('旧服务端不返回策略时不报错', () => {
const parsed = parseReleaseCapabilitiesResponse({ data: { production_release_requests_enabled: false, production_backup_restore_verified: false } })
expect(parsed.test_auto_review_policy).toBe('')
})
})
+5
View File
@@ -123,6 +123,8 @@ export interface ReleaseExecutionDetail extends ReleaseExecution {
export interface ReleaseCapabilities {
production_release_requests_enabled: boolean
production_backup_restore_verified: boolean
/** 当前审核策略(只读展示):off / internal / all。旧服务端不返回时按空串处理。 */
test_auto_review_policy: string
}
export interface ReleasePlanItem {
@@ -212,9 +214,12 @@ export function parseReleaseCapabilitiesResponse(value: unknown): ReleaseCapabil
if (!isRecord(value) || !isRecord(value.data) || typeof value.data.production_release_requests_enabled !== 'boolean' || typeof value.data.production_backup_restore_verified !== 'boolean') {
throw new Error('invalid release capabilities response')
}
// 审核策略是只读展示项:旧服务端不返回时不报错(空串 = 界面不显示这一行)。
const policy = typeof value.data.test_auto_review_policy === 'string' ? value.data.test_auto_review_policy : ''
return {
production_release_requests_enabled: value.data.production_release_requests_enabled,
production_backup_restore_verified: value.data.production_backup_restore_verified,
test_auto_review_policy: policy,
}
}