Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

feat: make requirement clarification optional (#145)

crispinhu2700875a8af81f
diff --git a/chatbot/src/platform.js b/chatbot/src/platform.js
index 0a3e222f..dfdeb448 100644
--- a/chatbot/src/platform.js
+++ b/chatbot/src/platform.js
@@ -9,7 +9,6 @@ export const actionNames = {
issues_dispatch: "派发 SOP",
issues_save: "保存需求",
issues_import_tapd: "导入 TAPD 需求",
- issues_clarify: "保存需求澄清",
issues_chat_clarify: "发起 AI 需求澄清",
issues_clarification_save: "保存并回写需求澄清",
issues_delete: "删除需求",
diff --git a/docs/api/README.md b/docs/api/README.md
index 1c74878e..ec4b46ad 100644
--- a/docs/api/README.md
+++ b/docs/api/README.md
@@ -84,7 +84,6 @@ curl -H "Authorization: Bearer $AGENTFLOW_TOKEN" "$AGENTFLOW_URL/api/health"
| `GET` | `/api/issues/{issueId}` |
| `POST` | `/api/issues/{issueId}/comments` |
| `GET` | `/api/issues/{issueId}/runs` |
-| `POST` | `/api/issues/{issueId}/clarify` |
| `POST` | `/api/issues/{issueId}/chat-clarify` |
| `POST` | `/api/issues/{issueId}/reopen` |
| `POST` | `/api/issues/{issueId}/dispatch` |
diff --git a/docs/api/collaboration.md b/docs/api/collaboration.md
index 83f8b78c..42ac55b5 100644
--- a/docs/api/collaboration.md
+++ b/docs/api/collaboration.md
@@ -32,8 +32,7 @@ curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" "$AGENTFLOW_URL/api/projects"
"codeBuddyApiKey":"",
"codeBuddyApiKeyClear":false,
"codeBuddyInternetEnvironmentClear":false,
- "tapdClear":false,
- "clarification":{"enabled":true,"threshold":80,"dimensions":[]}
+ "tapdClear":false
}
```
@@ -42,7 +41,7 @@ curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" "$AGENTFLOW_URL/api/projects"
```bash
curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" -X PUT \
-H 'Content-Type: application/json' \
- -d '{"id":"platform","name":"平台研发","clarification":{"enabled":false,"threshold":0}}' \
+ -d '{"id":"platform","name":"平台研发"}' \
"$AGENTFLOW_URL/api/projects"
```
@@ -82,7 +81,7 @@ curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" -X POST \
- `priority`、`kind`(`requirement|issue`)、`assigneeType`、`assigneeId`
- `workflowId`、`repositoryId`、`repositoryIds`、`baseBranch`、`repositoryBranches`、`latestTaskId`
- `source`(`local|gongfeng|tapd`)、`externalRef`
-- `clarification`:`score`、`passed`、`answers`、`dimensions`、`missing`、`status`(`in_progress|ready|needs_user`)、`assessedAt`。导入 TAPD 需求时立刻按标题+描述打分;`needs_user` 表示未达项目准入线,手动派发 SOP 会被 409。
+- `clarification`:`summary`、`status`(`analyzing|in_progress|ready`;历史数据可能是 `needs_user`)、`history`、`questions`、写回字段。澄清是可选步骤,不打分、不自动开始,也不阻止派发 SOP。
- 交付字段 `deliveryState`、`deliveryMrUrl`、`deliveryMrState`、`deliveryMrs`、`deliveryUpdatedAt`。`deliveryMrs` 每个仓库一项(`repositoryId`、`repository`、`project`、`iid`、`url`、`state`、`targetBranch`),由 SOP 成功时按仓库工作分支向工蜂查询 MR 得出,查不到才回退到 MR 类产物里同项目的链接;`deliveryMrUrl` 为第一项,`deliveryMrState` 为聚合状态(全部合入默认分支才是 `merged`)。
### `GET /api/issues`
@@ -144,16 +143,6 @@ curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" -X POST \
返回该 Issue 的 run 摘要数组,按时间倒序,`200`;Issue 不存在 `404`。摘要省略 artifacts 内容、遥测、日志、事件和 workflow snapshot,并截断部分文本。
-### `POST /api/issues/{issueId}/clarify`
-
-按项目配置的澄清维度计算分数:
-
-```json
-{"answers":{"scope":"仅修改 API 层并补充测试","acceptance":"所有接口测试通过"}}
-```
-
-成功 `200` 返回 `ClarificationAssessment` 并把 Issue `kind` 设为 `requirement`;项目不存在/存储错误 `400`,Issue 不存在 `404`。分数按维度字数加权,未达标时 `passed=false` 且 `status=needs_user`。
-
## AI 多轮澄清
### `POST /api/chat-clarify`
@@ -175,7 +164,9 @@ curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" -X POST \
请求结构相同,使用已保存 Issue 作为上下文;Issue 不存在 `404`。
-已保存 Issue 的澄清在**服务端后台任务**中执行:浏览器断开、关闭网页或点抽屉外都不会取消。前台仍可用 SSE 看思考过程;`GET` 同一路径(`Accept: text/event-stream`)可重新接入正在跑的任务。`POST /api/issues/{issueId}/chat-clarify/cancel` 只取消这一张单。手动导入 TAPD 或新建需求评分未达标时会自动排队澄清;外部同步进来的需求不评分、不自动澄清。
+已保存 Issue 的澄清在**服务端后台任务**中执行:浏览器断开、关闭网页或点抽屉外都不会取消。前台仍可用 SSE 看思考过程;`GET` 同一路径(`Accept: text/event-stream`)可重新接入正在跑的任务。`POST /api/issues/{issueId}/chat-clarify/cancel` 只取消这一张单。澄清只由用户发起,导入、新建、同步都不会自动开始;服务重启时只续跑重启前正在分析的那一轮。
+
+澄清只围绕这张工作项本身:标题和描述就是范围边界,代码里看到的相邻功能、用户回答带出的新诉求都不会被追问,只在结论的「不在本次范围」里列一句。剩余细节能按现有代码惯例假设时直接给出结论(`ready=true`),连续多轮后会主动收敛。
最长 10 分钟。响应模式:
diff --git a/docs/api/openapi.yaml b/docs/api/openapi.yaml
index 84075364..0e6e6a64 100644
--- a/docs/api/openapi.yaml
+++ b/docs/api/openapi.yaml
@@ -1145,7 +1145,7 @@ paths:
tags: [Issues]
operationId: importTAPDIssue
summary: Import one TAPD story, bug or task from a pasted link
- description: Scores the imported title and description against the project's clarification policy. Below-threshold requirements are marked needs_user and cannot be dispatched until they pass.
+ description: Imports the work item as-is. Clarification is optional and never started automatically; the item can be dispatched right away.
requestBody:
required: true
content:
@@ -1264,37 +1264,6 @@ paths:
$ref: "#/components/responses/Unauthorized"
"404":
$ref: "#/components/responses/NotFound"
- /api/issues/{issueId}/clarify:
- parameters:
- - $ref: "#/components/parameters/IssueId"
- post:
- tags: [Issues]
- operationId: assessIssueClarification
- requestBody:
- required: true
- content:
- application/json:
- schema:
- type: object
- required: [answers]
- properties:
- answers:
- type: object
- additionalProperties:
- type: string
- responses:
- "200":
- description: Clarification assessment
- content:
- application/json:
- schema:
- $ref: "#/components/schemas/ClarificationAssessment"
- "400":
- $ref: "#/components/responses/BadRequest"
- "401":
- $ref: "#/components/responses/Unauthorized"
- "404":
- $ref: "#/components/responses/NotFound"
/api/issues/{issueId}/chat-clarify:
parameters:
- $ref: "#/components/parameters/IssueId"
@@ -1371,18 +1340,6 @@ paths:
type: array
items:
$ref: "#/components/schemas/ClarificationQuestion"
- dimensions:
- type: object
- description: Per-dimension completeness ratings (0-100), folded into score with the project policy weights. For requirements this score gates SOP dispatch.
- additionalProperties:
- type: integer
- minimum: 0
- maximum: 100
- missing:
- type: array
- description: Key information still unconfirmed after clarification.
- items:
- type: string
retry:
type: boolean
responses:
@@ -4076,8 +4033,6 @@ components:
type: array
items:
$ref: "#/components/schemas/ProjectMember"
- clarification:
- $ref: "#/components/schemas/ClarificationPolicy"
tapdWorkspaceId:
type: string
tapdIterationId:
@@ -4148,32 +4103,6 @@ components:
claudeCodeApiKeyConfigured: {type: boolean, readOnly: true}
claudeCodeBaseUrl: {type: string}
codeBuddyInternetEnvironment: {type: string}
- ClarificationPolicy:
- type: object
- properties:
- enabled:
- type: boolean
- skillId:
- type: string
- threshold:
- type: integer
- minimum: 0
- maximum: 100
- dimensions:
- type: array
- items:
- type: object
- properties:
- id:
- type: string
- name:
- type: string
- question:
- type: string
- weight:
- type: integer
- minLength:
- type: integer
RepositoryInput:
type: object
required: [projectId]
@@ -4369,25 +4298,8 @@ components:
readOnly: true
ClarificationAssessment:
type: object
+ description: Optional AI clarification state. It carries no score and never gates SOP dispatch.
properties:
- score:
- type: integer
- minimum: 0
- maximum: 100
- passed:
- type: boolean
- answers:
- type: object
- additionalProperties:
- type: string
- dimensions:
- type: object
- additionalProperties:
- type: integer
- missing:
- type: array
- items:
- type: string
summary:
type: string
status:
@@ -4411,9 +4323,6 @@ components:
writeBackAt:
type: string
format: date-time
- assessedAt:
- type: string
- format: date-time
ClarificationMessage:
type: object
required: [role, content]
diff --git a/docs/api/orchestration.md b/docs/api/orchestration.md
index c37b3c73..cdd0692c 100644
--- a/docs/api/orchestration.md
+++ b/docs/api/orchestration.md
@@ -377,4 +377,4 @@ curl -u "$AGENTFLOW_USER:$AGENTFLOW_PASS" -X POST \
"$AGENTFLOW_URL/api/schedule-jobs/job-1/run"
```
-定时派发会冻结集成分支上下文,并避免同一需求重复执行。需求澄清未达标时本轮跳过该 Issue,不把整次任务标失败。Worker signals、实例 lease 和沙箱回收属于内部机制,不是调度公共 API。
+定时派发会冻结集成分支上下文,并避免同一需求重复执行。需求是否澄清过不影响派发。Worker signals、实例 lease 和沙箱回收属于内部机制,不是调度公共 API。
diff --git a/e2e/api/20-issues.test.mjs b/e2e/api/20-issues.test.mjs
index 8c354952..ced96ac6 100644
--- a/e2e/api/20-issues.test.mjs
+++ b/e2e/api/20-issues.test.mjs
@@ -3,7 +3,7 @@
// deleting a local requirement (refused while its run waits, history kept).
import { test, before, after } from 'node:test';
import assert from 'node:assert/strict';
-import { api, get, post, put, list, track, cleanup, ensureProject, setClarification, waitFor, waitRun } from '../lib/api.mjs';
+import { api, get, post, put, list, track, cleanup, ensureProject, waitFor, waitRun } from '../lib/api.mjs';
import { cfg } from '../lib/env.mjs';
import { createWorkflow, script, approval, trackRun } from '../lib/fixtures.mjs';
@@ -91,27 +91,13 @@ test('requirement view and SOP binding round-trip', async () => {
await api('PUT', `/api/issues/${issue.id}/sops`, { playbookId: 'e2e-no-such-playbook' }, { expect: 400 });
});
-test('clarification assessment answers with a structured verdict', async () => {
- const verdict = await post(`/api/issues/${issue.id}/clarify`, { answers: {} }, { expect: [200, 409], timeoutMs: 120_000 });
- assert.ok(verdict && typeof verdict === 'object');
-});
-
-test('clarification gate blocks dispatch of an assessed, under-scored requirement', async () => {
- // A requirement is gated once it has been assessed under an enabled policy.
- await setClarification(true);
- try {
- const vague = await post('/api/issues', { projectId: P, kind: 'requirement', title: `E2E 澄清门禁 ${cfg.runTag}`, description: '做个东西', workflowId });
- const verdict = await post(`/api/issues/${vague.id}/clarify`, { answers: {} });
- assert.equal(verdict.passed ?? verdict.clarification?.passed ?? false, false, `a two-word requirement must not pass: ${JSON.stringify(verdict).slice(0, 300)}`);
- const { issue: assessed } = await get(`/api/issues/${vague.id}`);
- assert.ok(assessed.clarification?.gated, `assessed requirement is not gated: ${JSON.stringify(assessed.clarification)}`);
- removeLater(vague.id);
- const res = await api('POST', `/api/issues/${vague.id}/dispatch`, { workflowId }, { expect: 409 });
- assert.match(JSON.stringify(res), /澄清/);
- assert.equal(list(await get(`/api/issues/${vague.id}/runs`)).length, 0, 'a refused dispatch must not start a run');
- } finally {
- await setClarification(false);
- }
+test('clarification is optional: no score endpoint, no auto-start on create', async () => {
+ await api('POST', `/api/issues/${issue.id}/clarify`, { answers: {} }, { expect: 404 });
+ const vague = await post('/api/issues', { projectId: P, kind: 'requirement', title: `E2E 澄清可选 ${cfg.runTag}`, description: '做个东西', workflowId });
+ removeLater(vague.id);
+ const { issue: created } = await get(`/api/issues/${vague.id}`);
+ const c = created.clarification || {};
+ assert.ok(!c.status && !c.gated && c.score === undefined, `a new requirement must not be scored or auto-clarified: ${JSON.stringify(c)}`);
});
test('dispatch starts a run linked to the issue and it succeeds', async () => {
diff --git a/e2e/lib/api.mjs b/e2e/lib/api.mjs
index b08bc9a4..2c63af2c 100644
--- a/e2e/lib/api.mjs
+++ b/e2e/lib/api.mjs
@@ -104,9 +104,6 @@ export async function cleanup() {
// ensureProject returns the long-lived e2e project. Projects have no delete
// endpoint, so the suite reuses one fixed project instead of leaking one per run.
-// A policy with enabled=false and no threshold counts as "unset" and falls back
-// to the platform default (enabled, 80 points), so disabling needs a threshold.
-export const CLARIFICATION_OFF = { enabled: false, skillId: 'requirement-clarification', threshold: 80 };
export async function ensureProject() {
let project = await get(`/api/projects/${cfg.projectId}`, { expect: [200, 404] });
@@ -117,13 +114,12 @@ export async function ensureProject() {
name: 'E2E 自动化测试(勿用)',
description: 'e2e/ 目录下的实测套件专用项目,资源会被自动创建和清理。',
color: '#8b5cf6',
- clarification: CLARIFICATION_OFF,
});
}
// AI analysis and dispatch need a responsible user; default to the token owner.
const ownerId = project.ownerId || (await tokenOwner()).id;
- if (project.clarification?.enabled || project.ownerId !== ownerId) {
- project = await put('/api/projects', { ...project, ownerId, clarification: { ...CLARIFICATION_OFF, ...project.clarification, enabled: false } });
+ if (project.ownerId !== ownerId) {
+ project = await put('/api/projects', { ...project, ownerId });
}
return project;
}
@@ -179,8 +175,3 @@ export async function withProjectMember(userId, role) {
track(`project members ${cfg.projectId}`, restore);
return restore;
}
-
-export async function setClarification(enabled) {
- const project = await get(`/api/projects/${cfg.projectId}`);
- return put('/api/projects', { ...project, clarification: { ...CLARIFICATION_OFF, ...project.clarification, enabled } });
-}
diff --git a/e2e/local.sh b/e2e/local.sh
index 059c9a08..2fa5660a 100755
--- a/e2e/local.sh
+++ b/e2e/local.sh
@@ -121,7 +121,7 @@ api() {
-X "$1" "$BASE$2" --data-raw "$3")
case "$code" in 2??) ;; *) echo "seed $1 $2 failed ($code): $(cat "$WORK/seed.out" 2>/dev/null)"; exit 1 ;; esac
}
-api POST /api/projects '{"id":"e2e-auto","key":"E2E","name":"E2E 自动化测试(勿用)","color":"#8b5cf6","ownerId":900001,"clarification":{"enabled":false,"skillId":"requirement-clarification","threshold":80}}'
+api POST /api/projects '{"id":"e2e-auto","key":"E2E","name":"E2E 自动化测试(勿用)","color":"#8b5cf6","ownerId":900001}'
api PUT /api/dockerfiles '{"id":"generic-backend","name":"generic backend","projectId":"e2e-auto","content":"FROM python:3.12-slim\nRUN apt-get update && apt-get install -y --no-install-recommends git ca-certificates && rm -rf /var/lib/apt/lists/*\n"}'
api PUT /api/sandboxes '{"id":"generic-docker","name":"Generic Docker","projectId":"e2e-auto","driver":"docker","dockerfileId":"generic-backend","readOnlyRootFS":false}'
api PUT /api/sandboxes '{"id":"local","name":"Local","projectId":"e2e-auto","driver":"local"}'
diff --git a/internal/application/operations.go b/internal/application/operations.go
index 2b96c001..548bdc02 100644
--- a/internal/application/operations.go
+++ b/internal/application/operations.go
@@ -40,7 +40,6 @@ func PublicOperations() []Operation {
{Name: "issues_delete", Description: "Delete a local issue and failed/cancelled execution history; reject successful or active runs", Method: "DELETE", Path: "/api/issues/{id}"},
{Name: "issues_comments_add", Description: "Add a comment to an issue", Method: "POST", Path: "/api/issues/{id}/comments"},
{Name: "issues_runs_list", Description: "List runs belonging to an issue", Method: "GET", Path: "/api/issues/{id}/runs", ReadOnly: true},
- {Name: "issues_clarify", Description: "Save structured requirement clarification", Method: "POST", Path: "/api/issues/{id}/clarify"},
{Name: "issues_chat_clarify", Description: "Run AI clarification for an existing issue. The job keeps running after the client disconnects; GET the same path with Accept: text/event-stream to resume SSE.", Method: "POST", Path: "/api/issues/{id}/chat-clarify"},
{Name: "issues_chat_clarify_stream", Description: "Attach to an in-flight issue clarification SSE stream", Method: "GET", Path: "/api/issues/{id}/chat-clarify", ReadOnly: true},
{Name: "issues_chat_clarify_cancel", Description: "Cancel one issue's in-flight AI clarification", Method: "POST", Path: "/api/issues/{id}/chat-clarify/cancel"},
diff --git a/internal/domain/clarification.go b/internal/domain/clarification.go
index 5db3e21e..4d774029 100644
--- a/internal/domain/clarification.go
+++ b/internal/domain/clarification.go
@@ -1,12 +1,6 @@
package domain
-import (
- "html"
- "regexp"
- "strings"
- "time"
- "unicode"
-)
+import "strings"
const (
ClarificationInProgress = "in_progress"
@@ -16,354 +10,9 @@ const (
ClarificationKickoff = "请先检查这张工作项的描述和相关代码,告诉我还缺哪些关键信息。"
)
-// DefaultClarificationPolicy is the fallback policy for projects that never
-// customised clarification. Import scoring and the SOP gate both use it.
-func DefaultClarificationPolicy() ClarificationPolicy {
- return ClarificationPolicy{Enabled: true, SkillID: "requirement-clarification", Threshold: 80, Dimensions: []ClarificationDimension{
- {ID: "goal", Name: "目标与价值", Question: "要解决什么问题,预期产生什么业务价值?", Weight: 20, MinLength: 30},
- {ID: "user", Name: "用户与场景", Question: "谁会在什么场景下使用?", Weight: 15, MinLength: 20},
- {ID: "scope", Name: "范围与边界", Question: "本次包含什么、不包含什么?", Weight: 20, MinLength: 30},
- {ID: "acceptance", Name: "验收标准", Question: "如何用可测试的条件判断需求完成?", Weight: 25, MinLength: 40},
- {ID: "constraints", Name: "约束与依赖", Question: "有哪些技术约束、依赖、风险或截止时间?", Weight: 20, MinLength: 25},
- }}
-}
-
-func (p ClarificationPolicy) IsZero() bool {
- return !p.Enabled && p.Threshold == 0 && p.SkillID == "" && len(p.Dimensions) == 0
-}
-
-// EffectiveClarificationPolicy fills missing dimensions from the default
-// policy. A completely unset policy is treated as the platform default so
-// imported requirements are always scored.
-func EffectiveClarificationPolicy(p ClarificationPolicy) ClarificationPolicy {
- if p.IsZero() {
- return DefaultClarificationPolicy()
- }
- if len(p.Dimensions) == 0 {
- p.Dimensions = DefaultClarificationPolicy().Dimensions
- }
- return p
-}
-
-func ClarificationPassed(policy ClarificationPolicy, score int) bool {
- policy = EffectiveClarificationPolicy(policy)
- return !policy.Enabled || score >= policy.Threshold
-}
-
-// ShouldRefreshImportScore reports whether an existing assessment may be
-// replaced by a fresh import-time score. Multi-turn conversations are kept.
-func ShouldRefreshImportScore(a ClarificationAssessment) bool {
- if len(a.History) > 0 {
- return false
- }
- switch a.Status {
- case ClarificationReady, ClarificationInProgress, ClarificationAnalyzing:
- return false
- }
- return true
-}
-
-// ShouldAutoStartClarification reports whether the server should kick off an
-// AI clarification round without a browser. Import scoring (needs_user, no
-// questions yet) and a crashed analyzing round both qualify; a round that
-// already asked the user waits for answers.
-func ShouldAutoStartClarification(issue Issue) bool {
- if !strings.EqualFold(issue.Kind, "requirement") {
- return false
- }
- if !issue.Clarification.Gated {
- return false
- }
- a := issue.Clarification
- if a.Passed || a.Status == ClarificationReady {
- return false
- }
- if len(a.Questions) > 0 {
- return false
- }
- switch a.Status {
- case ClarificationAnalyzing:
- return true
- case ClarificationNeedsUser, "":
- return true
- case ClarificationInProgress:
- if len(a.History) == 0 {
- return true
- }
- return strings.EqualFold(strings.TrimSpace(a.History[len(a.History)-1].Role), "user")
- }
- return false
-}
-
-// RequirementSOPBlocked reports whether a requirement is below the project's
-// clarification threshold. Gongfeng bugs, disabled policies, and tickets that
-// already finished an interactive clarification round are not blocked.
-func RequirementSOPBlocked(issue Issue, policy ClarificationPolicy) bool {
- if !strings.EqualFold(issue.Kind, "requirement") {
- return false
- }
- if !issue.Clarification.Gated {
- return false
- }
- if issue.Clarification.Status == ClarificationReady {
- return false
- }
- policy = EffectiveClarificationPolicy(policy)
- return policy.Enabled && !issue.Clarification.Passed
-}
-
-// ScoreClarificationDimensions folds per-dimension ratings (0-100) into a
-// single weighted score. Unrated dimensions count as zero and are still
-// stored, so a partial answer can never inflate the total or come back empty.
-func ScoreClarificationDimensions(dimensions []ClarificationDimension, ratings map[string]int) (int, map[string]int) {
- normalized := map[string]int{}
- if len(dimensions) == 0 {
- return 0, normalized
- }
- if ratings == nil {
- ratings = map[string]int{}
- }
- total, weightSum := 0, 0
- for _, dimension := range dimensions {
- weight := dimension.Weight
- if weight <= 0 {
- weight = 1
- }
- weightSum += weight
- rating := ratings[dimension.ID]
- if rating < 0 {
- rating = 0
- }
- if rating > 100 {
- rating = 100
- }
- normalized[dimension.ID] = rating
- total += rating * weight
- }
- if weightSum == 0 {
- return 0, normalized
- }
- return total / weightSum, normalized
-}
-
-func TrimClarificationMissing(missing []string) []string {
- out := make([]string, 0, len(missing))
- for _, item := range missing {
- if item = strings.TrimSpace(item); item != "" {
- out = append(out, item)
- }
- }
- if len(out) == 0 {
- return nil
- }
- return out
-}
-
-// AssessClarificationAnswers scores structured answers by length against each
-// dimension's minLength, then folds them with the policy weights.
-func AssessClarificationAnswers(policy ClarificationPolicy, answers map[string]string) ClarificationAssessment {
- policy = EffectiveClarificationPolicy(policy)
- if answers == nil {
- answers = map[string]string{}
- }
- score, totalWeight := 0, 0
- dimensions := map[string]int{}
- missing := []string{}
- for _, dimension := range policy.Dimensions {
- weight := dimension.Weight
- if weight <= 0 {
- weight = 1
- }
- totalWeight += weight
- minLength := dimension.MinLength
- if minLength <= 0 {
- minLength = 20
- }
- length := len([]rune(strings.TrimSpace(answers[dimension.ID])))
- dimensionScore := 0
- if minLength > 0 {
- dimensionScore = length * 100 / minLength
- }
- if dimensionScore > 100 {
- dimensionScore = 100
- }
- dimensions[dimension.ID] = dimensionScore
- score += dimensionScore * weight
- if dimensionScore < 100 {
- missing = append(missing, dimension.ID)
- }
- }
- if totalWeight > 0 {
- score /= totalWeight
- }
- assessment := ClarificationAssessment{
- Score: score,
- Passed: ClarificationPassed(policy, score),
- Answers: answers,
- Dimensions: dimensions,
- Missing: missing,
- AssessedAt: time.Now().UTC(),
- }
- if !assessment.Passed {
- assessment.Status = ClarificationNeedsUser
- }
- return assessment
-}
-
-// AssessRequirementText scores an unstructured title+description (TAPD import,
-// chat-created stories) against the policy dimensions. Matching excerpts are
-// length-scored; dimensions with no evidence stay at zero.
-func AssessRequirementText(policy ClarificationPolicy, title, description string) ClarificationAssessment {
- policy = EffectiveClarificationPolicy(policy)
- text := NormalizeRequirementText(title, description)
- answers := map[string]string{}
- for _, dimension := range policy.Dimensions {
- answers[dimension.ID] = excerptForDimension(text, dimension)
- }
- return AssessClarificationAnswers(policy, answers)
-}
-
-// ScoreRequirementIssue applies import-time scoring unless a conversation is
-// already in progress. Client-supplied dimension ratings, when present, are
-// folded with the policy weights instead of re-deriving excerpts.
-func ScoreRequirementIssue(issue Issue, policy ClarificationPolicy) ClarificationAssessment {
- if !strings.EqualFold(issue.Kind, "requirement") {
- return issue.Clarification
- }
- if !ShouldRefreshImportScore(issue.Clarification) {
- return issue.Clarification
- }
- policy = EffectiveClarificationPolicy(policy)
- if len(issue.Clarification.Dimensions) > 0 {
- score, rated := ScoreClarificationDimensions(policy.Dimensions, issue.Clarification.Dimensions)
- out := issue.Clarification
- out.Score = score
- out.Dimensions = rated
- out.Passed = ClarificationPassed(policy, score)
- out.Missing = TrimClarificationMissing(out.Missing)
- if len(out.Missing) == 0 {
- for _, dimension := range policy.Dimensions {
- if rated[dimension.ID] < 100 {
- out.Missing = append(out.Missing, dimension.ID)
- }
- }
- }
- out.AssessedAt = time.Now().UTC()
- if !out.Passed && out.Status == "" {
- out.Status = ClarificationNeedsUser
- }
- if out.Passed && out.Status == ClarificationNeedsUser {
- out.Status = ""
- }
- out.Gated = true
- return out
- }
- out := AssessRequirementText(policy, issue.Title, issue.Description)
- out.Gated = true
- return out
-}
-
-func NormalizeRequirementText(title, description string) string {
- parts := []string{strings.TrimSpace(title), StripRequirementHTML(description)}
- return strings.TrimSpace(strings.Join(parts, "\n"))
-}
-
-var htmlTagRe = regexp.MustCompile(`(?s)<[^>]*>`)
-
-func StripRequirementHTML(s string) string {
- s = htmlTagRe.ReplaceAllString(s, " ")
- s = html.UnescapeString(s)
- return strings.Join(strings.Fields(s), " ")
-}
-
-func excerptForDimension(text string, dimension ClarificationDimension) string {
- keys := dimensionKeywords(dimension)
- if text == "" || len(keys) == 0 {
- return ""
- }
- var hits []string
- for _, unit := range splitRequirementUnits(text) {
- if unitContainsKeyword(unit, keys) {
- hits = append(hits, unit)
- }
- }
- return strings.Join(hits, "\n")
-}
-
-func splitRequirementUnits(text string) []string {
- text = strings.ReplaceAll(text, "\r\n", "\n")
- var units []string
- for _, para := range strings.Split(text, "\n") {
- para = strings.TrimSpace(para)
- if para == "" {
- continue
- }
- start := 0
- for i, r := range para {
- if r == '。' || r == '!' || r == '?' || r == ';' || r == ';' {
- piece := strings.TrimSpace(para[start:i])
- if piece != "" {
- units = append(units, piece)
- }
- start = i + len(string(r))
- }
- }
- if tail := strings.TrimSpace(para[start:]); tail != "" {
- units = append(units, tail)
- }
- }
- return units
-}
-
-var (
- nameSplitter = regexp.MustCompile(`[与和或、,,/]`)
- questionTokenRe = regexp.MustCompile(`[\p{Han}]{2,}|[A-Za-z][A-Za-z0-9_-]{1,}`)
- clarificationStop = map[string]bool{
- "什么": true, "如何": true, "哪些": true, "怎么": true, "是否": true, "以及": true,
- "或者": true, "需要": true, "这个": true, "一个": true, "进行": true, "还有": true,
- "还是": true, "可以": true, "应该": true, "为了": true, "及其": true, "相关": true,
- "具体": true, "正确": true, "条件": true, "判断": true, "已经": true, "修复": true,
- "预期": true, "产生": true, "使用": true, "完成": true, "时间": true, "要求": true,
- }
-)
-
-func usefulKeyword(raw string) bool {
- n := 0
- for _, r := range raw {
- if unicode.IsLetter(r) || unicode.Is(unicode.Han, r) || unicode.IsDigit(r) {
- n++
- }
- }
- return n >= 2
-}
-
-func dimensionKeywords(dimension ClarificationDimension) []string {
- seen := map[string]bool{}
- var keys []string
- add := func(raw string) {
- raw = strings.TrimSpace(raw)
- if raw == "" || seen[raw] || clarificationStop[raw] || !usefulKeyword(raw) {
- return
- }
- seen[raw] = true
- keys = append(keys, raw)
- }
- for _, part := range nameSplitter.Split(dimension.Name, -1) {
- add(part)
- }
- for _, tok := range questionTokenRe.FindAllString(dimension.Question, -1) {
- add(tok)
- }
- add(dimension.ID)
- return keys
-}
-
-func unitContainsKeyword(unit string, keys []string) bool {
- lower := strings.ToLower(unit)
- for _, key := range keys {
- if strings.Contains(lower, strings.ToLower(key)) {
- return true
- }
- }
- return false
+// ShouldResumeClarification reports whether the server should resume an AI
+// clarification round without a browser. Clarification is always started by
+// the user; only a round that crashed mid-analysis is picked up again.
+func ShouldResumeClarification(issue Issue) bool {
+ return strings.TrimSpace(issue.ID) != "" && issue.Clarification.Status == ClarificationAnalyzing
}
diff --git a/internal/domain/clarification_test.go b/internal/domain/clarification_test.go
index c514ef5e..c96ddd7f 100644
--- a/internal/domain/clarification_test.go
+++ b/internal/domain/clarification_test.go
@@ -2,119 +2,21 @@ package domain
import "testing"
-func TestAssessRequirementTextNeverReturnsEmptyDimensions(t *testing.T) {
- got := AssessRequirementText(ClarificationPolicy{}, "短标题", "")
- if got.Score != 0 {
- t.Fatalf("empty body score=%d", got.Score)
- }
- if got.Passed {
- t.Fatal("empty body must not pass the default 80 threshold")
- }
- if got.Status != ClarificationNeedsUser {
- t.Fatalf("status=%q", got.Status)
- }
- policy := DefaultClarificationPolicy()
- if len(got.Dimensions) != len(policy.Dimensions) {
- t.Fatalf("dimensions=%v", got.Dimensions)
- }
- for _, dim := range policy.Dimensions {
- if _, ok := got.Dimensions[dim.ID]; !ok {
- t.Fatalf("missing dimension %s in %+v", dim.ID, got.Dimensions)
- }
- }
-}
-
-func TestAssessRequirementTextScoresCoveredDimensions(t *testing.T) {
- body := `<p>目标是解决国际站绑定套餐域名和国内站不一致的问题,预期产生对齐全站业务价值。</p>
-<p>用户是国际站套餐管理员,在续费场景下使用。</p>
-<p>本次范围包含取回绑定逻辑,不包含计费边界。</p>
-<p>验收标准:国内站与国际站绑定结果一致,相关接口测试通过即可判断完成。</p>
-<p>约束是必须兼容现有套餐依赖,本迭代截止前交付,注意回滚风险。</p>`
- got := AssessRequirementText(ClarificationPolicy{}, "国际站绑定对齐", body)
- if !got.Passed {
- t.Fatalf("complete TAPD description should pass: score=%d dims=%v missing=%v", got.Score, got.Dimensions, got.Missing)
- }
- if got.Score < 80 {
- t.Fatalf("score=%d", got.Score)
- }
- for id, v := range got.Dimensions {
- if v <= 0 {
- t.Fatalf("dimension %s scored %d, excerpts=%q", id, v, got.Answers[id])
+func TestShouldResumeClarificationOnlyForCrashedAnalysis(t *testing.T) {
+ cases := []struct {
+ name string
+ issue Issue
+ want bool
+ }{
+ {"analyzing", Issue{ID: "a", Clarification: ClarificationAssessment{Status: ClarificationAnalyzing}}, true},
+ {"fresh import", Issue{ID: "a", Kind: "requirement"}, false},
+ {"legacy needs_user", Issue{ID: "a", Kind: "requirement", Clarification: ClarificationAssessment{Status: ClarificationNeedsUser, Gated: true}}, false},
+ {"waiting for answers", Issue{ID: "a", Clarification: ClarificationAssessment{Status: ClarificationInProgress}}, false},
+ {"no id", Issue{Clarification: ClarificationAssessment{Status: ClarificationAnalyzing}}, false},
+ }
+ for _, tc := range cases {
+ if got := ShouldResumeClarification(tc.issue); got != tc.want {
+ t.Fatalf("%s: got %v want %v", tc.name, got, tc.want)
}
}
}
-
-func TestScoreClarificationDimensionsKeepsUnratedAsZero(t *testing.T) {
- dims := DefaultClarificationPolicy().Dimensions
- score, rated := ScoreClarificationDimensions(dims, map[string]int{"goal": 100})
- if rated["goal"] != 100 || rated["acceptance"] != 0 {
- t.Fatalf("rated=%v", rated)
- }
- if len(rated) != len(dims) {
- t.Fatalf("rated size=%d", len(rated))
- }
- if score <= 0 || score >= 80 {
- t.Fatalf("partial score=%d", score)
- }
- emptyScore, emptyRated := ScoreClarificationDimensions(dims, nil)
- if emptyScore != 0 || len(emptyRated) != len(dims) {
- t.Fatalf("empty ratings score=%d rated=%v", emptyScore, emptyRated)
- }
-}
-
-func TestShouldRefreshImportScore(t *testing.T) {
- if !ShouldRefreshImportScore(ClarificationAssessment{Score: 12, Status: ClarificationNeedsUser}) {
- t.Fatal("import score should refresh")
- }
- if ShouldRefreshImportScore(ClarificationAssessment{Status: ClarificationReady, Summary: "done"}) {
- t.Fatal("ready conversation must be kept")
- }
- if ShouldRefreshImportScore(ClarificationAssessment{Status: ClarificationAnalyzing}) {
- t.Fatal("analyzing round must be kept")
- }
- if ShouldRefreshImportScore(ClarificationAssessment{History: []ClarificationMessage{{Role: "user", Content: "x"}}}) {
- t.Fatal("history must be kept")
- }
-}
-
-func TestShouldAutoStartClarification(t *testing.T) {
- need := Issue{Kind: "requirement", Clarification: ClarificationAssessment{Status: ClarificationNeedsUser, Score: 12, Gated: true}}
- if !ShouldAutoStartClarification(need) {
- t.Fatal("import needs_user should auto-start")
- }
- if ShouldAutoStartClarification(Issue{Kind: "requirement", Clarification: ClarificationAssessment{Status: ClarificationNeedsUser, Score: 12}}) {
- t.Fatal("external sync tickets should not auto-start")
- }
- waiting := Issue{Kind: "requirement", Clarification: ClarificationAssessment{Status: ClarificationInProgress, Questions: []ClarificationQuestion{{ID: "q1", Question: "范围?"}}}}
- if ShouldAutoStartClarification(waiting) {
- t.Fatal("questions already asked wait for the user")
- }
- bug := Issue{Kind: "issue", Clarification: ClarificationAssessment{Status: ClarificationNeedsUser}}
- if ShouldAutoStartClarification(bug) {
- t.Fatal("non-requirements are not auto-clarified")
- }
-}
-
-func TestRequirementSOPBlocked(t *testing.T) {
- req := Issue{Kind: "requirement", Clarification: ClarificationAssessment{Score: 40}}
- if RequirementSOPBlocked(req, ClarificationPolicy{}) {
- t.Fatal("external sync tickets are not gated")
- }
- req.Clarification.Gated = true
- if !RequirementSOPBlocked(req, ClarificationPolicy{}) {
- t.Fatal("unmet manual requirement must block SOP")
- }
- req.Clarification.Passed = true
- req.Clarification.Score = 90
- if RequirementSOPBlocked(req, ClarificationPolicy{}) {
- t.Fatal("passed requirement must not block SOP")
- }
- ready := Issue{Kind: "requirement", Clarification: ClarificationAssessment{Gated: true, Score: 76, Status: ClarificationReady}}
- if RequirementSOPBlocked(ready, ClarificationPolicy{}) {
- t.Fatal("finished clarification must not keep the score gate")
- }
- bug := Issue{Kind: "issue", Clarification: ClarificationAssessment{Score: 0, Gated: true}}
- if RequirementSOPBlocked(bug, ClarificationPolicy{}) {
- t.Fatal("bugs are not gated by requirement clarification")
- }
-}
diff --git a/internal/domain/issue.go b/internal/domain/issue.go
index 7240cbcf..61d50a01 100644
--- a/internal/domain/issue.go
+++ b/internal/domain/issue.go
@@ -146,11 +146,6 @@ func (i Issue) WorkBranchForRepository(repositoryID string) string {
}
type ClarificationAssessment struct {
- Score int `json:"score"`
- Passed bool `json:"passed"`
- Answers map[string]string `json:"answers,omitempty"`
- Dimensions map[string]int `json:"dimensions,omitempty"`
- Missing []string `json:"missing,omitempty"`
Summary string `json:"summary,omitempty"`
Status string `json:"status,omitempty"` // analyzing, in_progress, ready, needs_user
History []ClarificationMessage `json:"history,omitempty"`
@@ -163,11 +158,9 @@ type ClarificationAssessment struct {
WriteBackAt time.Time `json:"writeBackAt,omitempty"`
// StartedAt is the first observed start of clarification, including
// pre-issue composer analysis when its server timestamp is carried over.
- StartedAt time.Time `json:"startedAt,omitempty"`
- AssessedAt time.Time `json:"assessedAt,omitempty"`
- // Gated is set when the issue was scored on a manual intake path
- // (新建需求 / 导入 TAPD). External sync leaves this false so those
- // tickets can be dispatched without the import-time score gate.
+ StartedAt time.Time `json:"startedAt,omitempty"`
+ // Gated is legacy: older TAPD imports were marked by it instead of
+ // ExternalRef.Imported. It is only read (tracker retention), never set.
Gated bool `json:"gated,omitempty"`
}
diff --git a/internal/domain/project.go b/internal/domain/project.go
index a7e7eed3..b2d98d6a 100644
--- a/internal/domain/project.go
+++ b/internal/domain/project.go
@@ -19,12 +19,11 @@ type Project struct {
SOPPlaybooks []SOPPlaybook `json:"sopPlaybooks,omitempty"`
// SOPBindings is the legacy single playbook. Empty SOPPlaybooks still
// expose it as the default combo so old projects keep working.
- SOPBindings []IssueSOPBinding `json:"sopBindings,omitempty"`
- DefaultRepositoryID string `json:"defaultRepositoryId,omitempty"`
- OwnerID int64 `json:"ownerId,omitempty"`
- Members []ProjectMember `json:"members,omitempty"`
- Clarification ClarificationPolicy `json:"clarification"`
- RunEval RunEvalPolicy `json:"runEval,omitempty"`
+ SOPBindings []IssueSOPBinding `json:"sopBindings,omitempty"`
+ DefaultRepositoryID string `json:"defaultRepositoryId,omitempty"`
+ OwnerID int64 `json:"ownerId,omitempty"`
+ Members []ProjectMember `json:"members,omitempty"`
+ RunEval RunEvalPolicy `json:"runEval,omitempty"`
// Deprecated project-level credential fields are kept only so old payloads
// can be decoded and scrubbed by the schema migration.
GitToken string `json:"-"`
@@ -64,21 +63,6 @@ type ProjectMember struct {
Role string `json:"role"` // maintainer, member, viewer
}
-type ClarificationDimension struct {
- ID string `json:"id"`
- Name string `json:"name"`
- Question string `json:"question"`
- Weight int `json:"weight"`
- MinLength int `json:"minLength"`
-}
-
-type ClarificationPolicy struct {
- Enabled bool `json:"enabled"`
- SkillID string `json:"skillId,omitempty"`
- Threshold int `json:"threshold"`
- Dimensions []ClarificationDimension `json:"dimensions,omitempty"`
-}
-
type Repository struct {
ID string `json:"id"`
ProjectID string `json:"projectId"`
diff --git a/internal/httpapi/agent_tool_terminal.go b/internal/httpapi/agent_tool_terminal.go
index 9abcb6bb..5c6818d8 100644
--- a/internal/httpapi/agent_tool_terminal.go
+++ b/internal/httpapi/agent_tool_terminal.go
@@ -39,7 +39,7 @@ func terminalToolDescriptors(mode AgentToolMode, exec assistantExecMode) []agent
schema, _ := json.Marshal(submitClarificationSchema())
return []agentToolDescriptor{{
Name: submitClarificationTool,
- Description: "调用本工具提交本轮澄清结论。ready=true 时提供 summary;否则必须提供具体问题,不能只在 summary 或 assessment.missing 里描述缺口。选择题提供至少两个不同的 options;需要用户填写路径、数量等内容时设 freeText=true、options=[]。校验失败时修正参数重新调用,提交成功才结束本轮。",
+ Description: "调用本工具提交本轮澄清结论。ready=true 时提供 summary;否则必须提供具体问题,不能只在 summary 里描述缺口。选择题提供至少两个不同的 options;需要用户填写路径、数量等内容时设 freeText=true、options=[]。校验失败时修正参数重新调用,提交成功才结束本轮。",
InputSchema: schema,
Kind: "terminal",
Terminal: true,
@@ -100,15 +100,7 @@ func submitClarificationSchema() map[string]any {
},
},
},
- "ready": map[string]any{"type": "boolean"},
- "assessment": map[string]any{
- "type": "object",
- "additionalProperties": false,
- "properties": map[string]any{
- "dimensions": map[string]any{"type": "object", "additionalProperties": map[string]any{"type": "integer"}},
- "missing": map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
- },
- },
+ "ready": map[string]any{"type": "boolean", "description": "本需求自身的范围已经足够开工时为 true,并在 summary 给出澄清结论"},
},
}
}
@@ -166,22 +158,17 @@ func parseSubmitClarificationArgs(raw json.RawMessage) (clarifyModelResult, erro
return clarifyModelResult{}, fmt.Errorf("submit_clarification 不接受 mcpCalls")
}
var payload struct {
- Summary string `json:"summary"`
- Questions []domain.ClarificationQuestion `json:"questions"`
- Ready bool `json:"ready"`
- Assessment struct {
- Dimensions map[string]int `json:"dimensions"`
- Missing []string `json:"missing"`
- } `json:"assessment"`
+ Summary string `json:"summary"`
+ Questions []domain.ClarificationQuestion `json:"questions"`
+ Ready bool `json:"ready"`
}
if err := json.Unmarshal(raw, &payload); err != nil {
return clarifyModelResult{}, fmt.Errorf("submit_clarification 参数无效: %w", err)
}
result := clarifyModelResult{
- Summary: strings.TrimSpace(payload.Summary),
- Questions: sanitizeClarificationQuestions(payload.Questions),
- Ready: payload.Ready,
- Assessment: payload.Assessment,
+ Summary: strings.TrimSpace(payload.Summary),
+ Questions: sanitizeClarificationQuestions(payload.Questions),
+ Ready: payload.Ready,
}
if utf8.RuneCountInString(result.Summary) > agentToolMaxSummaryLen {
result.Summary = string([]rune(result.Summary)[:agentToolMaxSummaryLen])
@@ -193,10 +180,6 @@ func parseSubmitClarificationArgs(raw json.RawMessage) (clarifyModelResult, erro
"summary": result.Summary,
"questions": result.Questions,
"ready": result.Ready,
- "assessment": map[string]any{
- "dimensions": result.Assessment.Dimensions,
- "missing": result.Assessment.Missing,
- },
}
result.raw = rawMap
return result, nil
@@ -211,7 +194,7 @@ func validateSubmitClarification(result clarifyModelResult) error {
return fmt.Errorf("ready 结论缺少 summary")
}
if len(result.Questions) == 0 {
- return fmt.Errorf("ready=false 时 questions 至少需要一个具体问题,不能只提交 summary 或 assessment.missing。请补齐问题及选项后重新调用 submit_clarification;开放填写题使用 freeText=true、options=[]")
+ return fmt.Errorf("ready=false 时 questions 至少需要一个具体问题,不能只提交 summary。请补齐问题及选项后重新调用 submit_clarification;开放填写题使用 freeText=true、options=[]")
}
seen := map[string]bool{}
for _, q := range result.Questions {
diff --git a/internal/httpapi/clarification_score.go b/internal/httpapi/clarification_score.go
deleted file mode 100644
index 0ad13a69..00000000
--- a/internal/httpapi/clarification_score.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package httpapi
-
-import (
- "fmt"
- "strings"
-
- "agentflow/internal/domain"
-)
-
-// issueClarificationDimensions rates bug-style work items. Requirements are
-// rated against the project's configurable policy instead, because that policy
-// also drives the pre-existing SOP gate.
-var issueClarificationDimensions = []domain.ClarificationDimension{
- {ID: "phenomenon", Name: "现象与复现", Question: "具体现象是什么,如何稳定复现?", Weight: 25},
- {ID: "impact", Name: "影响范围", Question: "影响哪些模块、用户或环境?", Weight: 20},
- {ID: "expected", Name: "期望行为", Question: "修复后正确的行为是什么?", Weight: 25},
- {ID: "acceptance", Name: "验收标准", Question: "如何用可测试的条件判断已修复?", Weight: 20},
- {ID: "constraints", Name: "约束与依赖", Question: "有哪些技术约束、依赖或时间要求?", Weight: 10},
-}
-
-// clarificationRatingDimensions returns the dimensions used to rate how complete
-// a work item's clarification is.
-func clarificationRatingDimensions(issue domain.Issue, project domain.Project, projectFound bool) []domain.ClarificationDimension {
- if isBugStyleWorkItem(issue) {
- return issueClarificationDimensions
- }
- if projectFound {
- return domain.EffectiveClarificationPolicy(project.Clarification).Dimensions
- }
- return domain.DefaultClarificationPolicy().Dimensions
-}
-
-func isBugStyleWorkItem(issue domain.Issue) bool {
- return strings.EqualFold(issue.Source, "gongfeng") || strings.EqualFold(issue.Kind, "issue")
-}
-
-func scoreClarificationDimensions(dimensions []domain.ClarificationDimension, ratings map[string]int) (int, map[string]int) {
- return domain.ScoreClarificationDimensions(dimensions, ratings)
-}
-
-func trimClarificationMissing(missing []string) []string {
- return domain.TrimClarificationMissing(missing)
-}
-
-// clarificationRatingPrompt describes the rating contract appended to the
-// clarification prompt once the model believes it has enough information.
-func clarificationRatingPrompt(dimensions []domain.ClarificationDimension) string {
- if len(dimensions) == 0 {
- return ""
- }
- var b strings.Builder
- b.WriteString("\n每轮都必须返回 assessment:对以下维度各打 0-100 分(依据是当前描述加上对话里已确认的信息,没有依据就给低分,不要一律给满分)。ready=false 时也要打分,并在 missing 里列出还缺的关键信息,方便用户判断还要不要继续问。只有目标、范围、验收标准都已经明确到可以开工时,才把 ready 设为 true:\n")
- for _, dimension := range dimensions {
- b.WriteString(fmt.Sprintf("- %s(%s):%s\n", dimension.ID, dimension.Name, dimension.Question))
- }
- b.WriteString(`格式:"assessment":{"dimensions":{"` + dimensions[0].ID + `":80},"missing":["仍然没有确认的关键信息,每条一句话"]}` + "\n")
- return b.String()
-}
diff --git a/internal/httpapi/clarify_jobs.go b/internal/httpapi/clarify_jobs.go
index 324a765d..12197629 100644
--- a/internal/httpapi/clarify_jobs.go
+++ b/internal/httpapi/clarify_jobs.go
@@ -122,13 +122,16 @@ func (j *clarifyJob) finished() bool {
}
}
-func (h *streamHandlers) autoClarifyIssue(issueID string) {
+// resumeClarifyIssue picks up a clarification round that was interrupted
+// mid-analysis (process restart). Clarification itself is never started
+// automatically; the user opens it from the issue or the composer.
+func (h *streamHandlers) resumeClarifyIssue(issueID string) {
issueID = strings.TrimSpace(issueID)
if issueID == "" || h == nil || h.repo == nil {
return
}
issue, ok := h.repo.Issue(issueID)
- if !ok || !domain.ShouldAutoStartClarification(issue) {
+ if !ok || !domain.ShouldResumeClarification(issue) {
return
}
if h.jobRunning(issueID) {
@@ -136,7 +139,7 @@ func (h *streamHandlers) autoClarifyIssue(issueID string) {
}
req := chatClarifyRequest{Message: domain.ClarificationKickoff, History: historyToClarify(issue.Clarification.History)}
if _, err := h.ensureClarifyJob(issue, req); err != nil {
- log.Printf("auto clarify %s: %v", issueID, err)
+ log.Printf("resume clarify %s: %v", issueID, err)
}
}
@@ -146,7 +149,7 @@ func (h *streamHandlers) recoverClarifyJobs() {
}
for _, issue := range h.repo.Issues() {
if issue.Clarification.Status == domain.ClarificationAnalyzing {
- h.autoClarifyIssue(issue.ID)
+ h.resumeClarifyIssue(issue.ID)
}
}
}
@@ -558,14 +561,10 @@ func (h *streamHandlers) persistClarifyOutcome(issueID string, parsed any, raw s
}
type clarifyModelResult struct {
- Summary string `json:"summary"`
- Questions []domain.ClarificationQuestion `json:"questions"`
- Ready bool `json:"ready"`
- Assessment struct {
- Dimensions map[string]int `json:"dimensions"`
- Missing []string `json:"missing"`
- } `json:"assessment"`
- raw map[string]any
+ Summary string `json:"summary"`
+ Questions []domain.ClarificationQuestion `json:"questions"`
+ Ready bool `json:"ready"`
+ raw map[string]any
}
func parseClarifyModel(parsed any, raw string) clarifyModelResult {
@@ -600,6 +599,7 @@ func parseClarifyModel(parsed any, raw string) clarifyModelResult {
result.raw["summary"] = result.Summary
result.raw["questions"] = result.Questions
result.raw["ready"] = result.Ready
+ delete(result.raw, "assessment")
return result
}
@@ -624,10 +624,6 @@ func clarificationAPIPayload(c domain.ClarificationAssessment) map[string]any {
"summary": c.Summary,
"questions": c.Questions,
"ready": c.Status == domain.ClarificationReady,
- "assessment": map[string]any{
- "dimensions": c.Dimensions,
- "missing": c.Missing,
- },
}
}
@@ -825,32 +821,6 @@ func (h *streamHandlers) saveClarificationAssessment(issueID string, result clar
}
assessment.Status = domain.ClarificationReady
issue.Description = appendClarificationDescription(issue.Description, assessment.Summary)
- project, found := h.repo.Project(issue.ProjectID)
- dimensions := clarificationRatingDimensions(*issue, project, found)
- score, rated := scoreClarificationDimensions(dimensions, result.Assessment.Dimensions)
- assessment.Score = score
- assessment.Dimensions = rated
- assessment.Missing = trimClarificationMissing(result.Assessment.Missing)
- if len(assessment.Missing) == 0 {
- for _, dim := range dimensions {
- if rated[dim.ID] < 100 {
- assessment.Missing = append(assessment.Missing, dim.ID)
- }
- }
- }
- if isBugStyleWorkItem(*issue) {
- assessment.Passed = true
- } else {
- policy := domain.DefaultClarificationPolicy()
- if found {
- policy = domain.EffectiveClarificationPolicy(project.Clarification)
- }
- assessment.Passed = domain.ClarificationPassed(policy, score)
- }
- assessment.AssessedAt = time.Now().UTC()
- if !isBugStyleWorkItem(*issue) {
- assessment.Gated = true
- }
promoteClarifiedIssueTodo(issue)
fingerprint := fmt.Sprintf("%x", sha256.Sum256([]byte(assessment.Summary)))
if assessment.WriteBackStatus != "succeeded" || assessment.WriteBackFingerprint != fingerprint {
@@ -860,14 +830,6 @@ func (h *streamHandlers) saveClarificationAssessment(issueID string, result clar
}
} else {
assessment.Status = domain.ClarificationInProgress
- if len(result.Assessment.Dimensions) > 0 {
- project, found := h.repo.Project(issue.ProjectID)
- dimensions := clarificationRatingDimensions(*issue, project, found)
- score, rated := scoreClarificationDimensions(dimensions, result.Assessment.Dimensions)
- assessment.Score = score
- assessment.Dimensions = rated
- assessment.Missing = trimClarificationMissing(result.Assessment.Missing)
- }
}
issue.Clarification = assessment
return nil
diff --git a/internal/httpapi/clarify_jobs_test.go b/internal/httpapi/clarify_jobs_test.go
index d7fde6f3..2b62c9e5 100644
--- a/internal/httpapi/clarify_jobs_test.go
+++ b/internal/httpapi/clarify_jobs_test.go
@@ -42,7 +42,7 @@ func TestIssueClarifyContinuesAfterClientDisconnect(t *testing.T) {
t.Cleanup(func() { setClarifyExecForTest(nil) })
s, h := clarifyTestServer(t)
- if err := s.PutIssue(domain.Issue{ID: "iss-clarify-bg", ProjectID: "platform", Title: "需要澄清", Description: "短", Kind: "requirement", Status: "backlog", Clarification: domain.ClarificationAssessment{Status: domain.ClarificationNeedsUser, Score: 10}}); err != nil {
+ if err := s.PutIssue(domain.Issue{ID: "iss-clarify-bg", ProjectID: "platform", Title: "需要澄清", Description: "短", Kind: "requirement", Status: "backlog", Clarification: domain.ClarificationAssessment{Status: domain.ClarificationNeedsUser}}); err != nil {
t.Fatal(err)
}
body, _ := json.Marshal(map[string]any{"message": domain.ClarificationKickoff})
diff --git a/internal/httpapi/clarify_session.go b/internal/httpapi/clarify_session.go
index 46c228b9..67bc7ced 100644
--- a/internal/httpapi/clarify_session.go
+++ b/internal/httpapi/clarify_session.go
@@ -271,16 +271,37 @@ func captureClarifySessionID(line string) string {
return strings.TrimSpace(sid)
}
-func clarifyResumeTurnPrompt(message string) string {
+// clarifyResumeTurnPrompt re-anchors every resumed round on the original
+// work item: long sessions otherwise drift toward whatever the latest answer
+// or the code just read happened to mention.
+func clarifyResumeTurnPrompt(title, message string, assistantRounds int) string {
msg := strings.TrimSpace(message)
if msg == "" {
msg = "请基于会话里已有信息继续澄清。"
}
- return "这是用户对本轮澄清的回复。结合会话中已读过的代码、原单、评论和对话继续,不要重复已问过的问题,不要再读已经成功读过的同一原单/评论/文档。完成后调用 submit_clarification。\n用户:" + msg
+ var b strings.Builder
+ b.WriteString("这是用户对本轮澄清的回复。结合会话中已读过的代码、原单、评论和对话继续,不要重复已问过的问题,不要再读已经成功读过的同一原单/评论/文档。")
+ if title = strings.TrimSpace(title); title != "" {
+ b.WriteString("\n范围锚点:本次只澄清「" + title + "」本身,遵守首轮约定的范围规则;用户回答若带出这条需求以外的新诉求,不要沿着追问,写进 summary 的「不在本次范围」并建议另建需求。")
+ }
+ b.WriteString(clarifyRoundBudgetHint(assistantRounds))
+ b.WriteString("完成后调用 submit_clarification。\n用户:")
+ b.WriteString(msg)
+ return b.String()
+}
+
+// clarifyRoundBudgetHint nudges the model to conclude once several rounds
+// have passed; without a stop condition it keeps finding "new" questions,
+// and the only new ones left are about neighbouring features.
+func clarifyRoundBudgetHint(assistantRounds int) string {
+ if assistantRounds < 3 {
+ return ""
+ }
+ return fmt.Sprintf("\n已经澄清了 %d 轮:除非还有不回答就无法开工的缺口,本轮直接给出结论(ready=true),剩余不确定点按现有代码惯例做合理假设并写进 summary。", assistantRounds)
}
func clarifyNativeRetryPrompt() string {
- return "刚才未成功提交有效的澄清结果,本轮尚未结束。请根据工具校验错误修正并重新调用 submit_clarification。ready=false 必须提供具体 questions,不能只有 summary 或 assessment.missing;选择题 options 至少包含两个不同选项,开放填写题设 freeText=true、options=[]。不要为了通过校验把尚缺关键信息的需求设为 ready=true。"
+ return "刚才未成功提交有效的澄清结果,本轮尚未结束。请根据工具校验错误修正并重新调用 submit_clarification。ready=false 必须提供具体 questions,不能只有 summary;选择题 options 至少包含两个不同选项,开放填写题设 freeText=true、options=[]。如果其实已经没有阻塞开工的缺口,就提交 ready=true 并给出 summary。"
}
func isClarifyProtocolObject(v any) bool {
@@ -322,20 +343,27 @@ func classifyClarifyProtocolError(err error) string {
}
}
-func clarifySystemPrompt(intro, mcpStep, focus, ratingPrompt string) string {
+func clarifySystemPrompt(intro, mcpStep, focus string) string {
return fmt.Sprintf(`%s
-1. 用 Read/Grep/Glob 读取当前工作目录代码,理解相关模块和现有实现
+1. 用 Read/Grep/Glob 读取当前工作目录代码,定位这条工作项要改的位置和现有实现
%s
-3. 围绕%s,基于代码、原单/评论和对话历史判断还缺什么关键信息
+3. 围绕%s,基于代码、原单/评论和对话历史判断还缺什么阻塞开工的信息
4. 完成后调用 submit_clarification。只有调用该工具才算结束本轮。
+范围规则(最重要):
+- 「## 需求」里的标题和描述就是本次范围的边界。只澄清把这一条需求做完所必需的信息,不负责规划整个模块或项目
+- 读代码是为了定位改动点、确认现有行为,不是为了寻找还能顺带做的事。代码里看到的相邻功能、历史问题、可优化点、未来扩展,都不要提问
+- 不要提出会扩大范围的问题或选项(例如「是否同时支持 X」「要不要顺便改 Y」「其他页面要不要一起改」)。确实值得提醒的相邻事项,只在 summary 的「不在本次范围」里列一句
+- 用户回答里带出这条需求以外的新诉求时,不要沿着追问,记入「不在本次范围」并建议另建需求
+- 不要为了凑问题而提问:能按现有代码惯例合理假设的细节直接假设,写进 summary;没有阻塞开工的缺口就设 ready=true
+
问题要具体、基于代码:
-- 不问"范围是什么",而是问"这个功能涉及 X 模块和 Y 模块,主要改哪个?"
-- 不问"优先级",而是问"这个是 P0(阻塞发布)还是 P1(下版本)?"
-- 每轮只问 1-3 个最关键的新问题,放入 questions,不要只在 summary 或 assessment.missing 中列出缺口
-- ready=false 时必须有问题。选择题 options 至少提供两个不同、具体可操作的选项;需要用户填写路径、数量等内容时使用 freeText=true、options=[]、multiSelect=false,不编造选项
-- 工具校验失败时修正参数并重新提交,不要为了通过校验把尚缺关键信息的需求设为 ready=true
+- 不问"范围是什么",而是问"需求说改 X,代码里 X 由 A 处理,是在 A 上改还是新增入口?"——问题必须落在需求原文已经提到的东西上
+- 每轮只问 1-3 个最关键的新问题,放入 questions,不要只在 summary 中列出缺口
+- ready=false 时必须有问题。选择题 options 至少提供两个不同、具体可操作的选项,选项都应在本需求范围内;需要用户填写路径、数量等内容时使用 freeText=true、options=[]、multiSelect=false,不编造选项
+- ready=true 时 summary 按「本次范围 / 不在本次范围 / 验收标准 / 假设」分段给出结论
+- 工具校验失败时修正参数并重新提交
- TAPD 的 id、workspace_id、entry_id 必须用字符串
- 思考用中文对用户说正在读代码或原单
-%s`, intro, mcpStep, focus, ratingPrompt)
+`, intro, mcpStep, focus)
}
diff --git a/internal/httpapi/dispatch.go b/internal/httpapi/dispatch.go
index c4c32178..05f391f9 100644
--- a/internal/httpapi/dispatch.go
+++ b/internal/httpapi/dispatch.go
@@ -43,10 +43,6 @@ func dispatchIssue(d *deps, req dispatchRequest) (domain.Task, error) {
}
scheduled := strings.TrimSpace(req.ScheduleJobID) != ""
project, _ := d.repo.Project(issue.ProjectID)
- policy := domain.EffectiveClarificationPolicy(project.Clarification)
- if domain.RequirementSOPBlocked(issue, policy) {
- return domain.Task{}, HTTPError{http.StatusConflict, fmt.Sprintf("需求澄清未达标:当前 %d 分,需要 %d 分", issue.Clarification.Score, policy.Threshold)}
- }
workflowID := strings.TrimSpace(req.WorkflowID)
if workflowID == "" {
workflowID = issue.WorkflowID
@@ -135,16 +131,6 @@ func dispatchIssue(d *deps, req dispatchRequest) (domain.Task, error) {
if summary := strings.TrimSpace(issue.Clarification.Summary); summary != "" {
input += "\n\nClarification summary:\n" + summary
}
- if issue.Kind == "requirement" && len(issue.Clarification.Answers) > 0 {
- input += fmt.Sprintf("\n\nClarification score: %d/100 (passed=%t)", issue.Clarification.Score, issue.Clarification.Passed)
- if p, ok := d.repo.Project(issue.ProjectID); ok {
- for _, d := range p.Clarification.Dimensions {
- if a := issue.Clarification.Answers[d.ID]; a != "" {
- input += "\n- " + d.Name + ": " + a
- }
- }
- }
- }
if len(repositories) > 0 {
if len(repositories) == 1 {
input += "\n\nRepository context (frozen): the repository is checked out in a first-level subdirectory; SOP deliverables stay at the workspace root"
diff --git a/internal/httpapi/issue_base_branch_test.go b/internal/httpapi/issue_base_branch_test.go
index 043ac4e1..cd60660a 100644
--- a/internal/httpapi/issue_base_branch_test.go
+++ b/internal/httpapi/issue_base_branch_test.go
@@ -51,7 +51,7 @@ func TestIssueBaseBranchCreateEditAndDefault(t *testing.T) {
if _, err := st.PatchIssue(created.ID, func(issue *domain.Issue) error {
issue.Clarification.SessionID = "original-branch-session"
issue.Clarification.SessionUserID = 42
- issue.Clarification.Answers = map[string]string{"scope": "保留业务范围"}
+ issue.Clarification.Summary = "保留业务范围"
issue.Clarification.History = []domain.ClarificationMessage{{Role: "user", Content: "保留业务回答"}}
return nil
}); err != nil {
@@ -69,7 +69,7 @@ func TestIssueBaseBranchCreateEditAndDefault(t *testing.T) {
if reset.BaseBranch != "" {
t.Fatalf("explicit blank must restore dynamic default: %+v", reset)
}
- if reset.Clarification.SessionID != "" || reset.Clarification.SessionUserID != 0 || reset.Clarification.Answers["scope"] != "保留业务范围" || len(reset.Clarification.History) != 1 {
+ if reset.Clarification.SessionID != "" || reset.Clarification.SessionUserID != 0 || reset.Clarification.Summary != "保留业务范围" || len(reset.Clarification.History) != 1 {
t.Fatalf("branch changes must discard the code session and preserve business answers: %+v", reset.Clarification)
}
if len(reset.Operations) == 0 || !strings.Contains(reset.Operations[len(reset.Operations)-1].Detail, "工作分支改为自动新建") {
@@ -148,7 +148,7 @@ func TestImportTAPDBaseBranchSelectionAndReimport(t *testing.T) {
if _, err := st.PatchIssue(imported.ID, func(issue *domain.Issue) error {
issue.Clarification.SessionID = "imported-branch-session"
issue.Clarification.SessionUserID = owner.ID
- issue.Clarification.Answers = map[string]string{"scope": "保留导入回答"}
+ issue.Clarification.Summary = "保留导入回答"
return nil
}); err != nil {
t.Fatal(err)
@@ -163,7 +163,7 @@ func TestImportTAPDBaseBranchSelectionAndReimport(t *testing.T) {
if changed.BaseBranch != "release/2026" {
t.Fatalf("reimport must apply an explicit changed selection: %+v", changed)
}
- if changed.Clarification.SessionID != "" || changed.Clarification.SessionUserID != 0 || changed.Clarification.Answers["scope"] != "保留导入回答" {
+ if changed.Clarification.SessionID != "" || changed.Clarification.SessionUserID != 0 || changed.Clarification.Summary != "保留导入回答" {
t.Fatalf("reimported branch changes must invalidate the code session only: %+v", changed.Clarification)
}
payload["baseBranch"] = ""
@@ -245,13 +245,13 @@ func TestIssueRepositoryChangeInvalidatesClarifySession(t *testing.T) {
}
}
issue := domain.Issue{ID: "repo-switch", ProjectID: "platform", Title: "更换分析仓库", RepositoryID: "original-repo", BaseBranch: "feature/continue",
- Clarification: domain.ClarificationAssessment{SessionID: "original-repo-session", SessionUserID: 42, Answers: map[string]string{"scope": "保留回答"}}}
+ Clarification: domain.ClarificationAssessment{SessionID: "original-repo-session", SessionUserID: 42, Summary: "保留回答"}}
if err := st.PutIssue(issue); err != nil {
t.Fatal(err)
}
h := New(st, engine.New(st, runtime.NewManager(filepath.Join(t.TempDir(), "workspaces"))), tracker.NewService(), "", "")
updated := requestJSON[domain.Issue](t, h, http.MethodPut, "/api/issues", map[string]any{"id": issue.ID, "repositoryId": "new-repo"}, http.StatusOK)
- if updated.BaseBranch != issue.BaseBranch || updated.Clarification.SessionID != "" || updated.Clarification.SessionUserID != 0 || updated.Clarification.Answers["scope"] != "保留回答" {
+ if updated.BaseBranch != issue.BaseBranch || updated.Clarification.SessionID != "" || updated.Clarification.SessionUserID != 0 || updated.Clarification.Summary != "保留回答" {
t.Fatalf("repository changes must invalidate the old code session: %+v", updated)
}
}
diff --git a/internal/httpapi/issue_repository_branches_test.go b/internal/httpapi/issue_repository_branches_test.go
index 77a05e99..9c965577 100644
--- a/internal/httpapi/issue_repository_branches_test.go
+++ b/internal/httpapi/issue_repository_branches_test.go
@@ -52,7 +52,7 @@ func TestIssueRepositoryBranchesCreateEditAndReset(t *testing.T) {
if _, err := st.PatchIssue(created.ID, func(issue *domain.Issue) error {
issue.Clarification.SessionID = "multi-repo-session"
issue.Clarification.SessionUserID = 1
- issue.Clarification.Answers = map[string]string{"scope": "保留业务回答"}
+ issue.Clarification.Summary = "保留业务回答"
return nil
}); err != nil {
t.Fatal(err)
@@ -67,7 +67,7 @@ func TestIssueRepositoryBranchesCreateEditAndReset(t *testing.T) {
changed := requestJSON[domain.Issue](t, h, http.MethodPut, "/api/issues", map[string]any{
"id": created.ID, "repositoryBranches": branches,
}, http.StatusOK)
- if !maps.Equal(changed.RepositoryBranches, branches) || changed.Clarification.SessionID != "" || changed.Clarification.SessionUserID != 0 || changed.Clarification.Answers["scope"] != "保留业务回答" {
+ if !maps.Equal(changed.RepositoryBranches, branches) || changed.Clarification.SessionID != "" || changed.Clarification.SessionUserID != 0 || changed.Clarification.Summary != "保留业务回答" {
t.Fatalf("secondary branch changes must reset code context and retain business answers: %+v", changed)
}
if len(changed.Operations) == 0 || !strings.Contains(changed.Operations[len(changed.Operations)-1].Detail, "各仓库继续开发分支") {
@@ -144,7 +144,7 @@ func testImportTAPDRepositoryBranches(t *testing.T, st *repo.Store) {
if _, err := st.PatchIssue(imported.ID, func(issue *domain.Issue) error {
issue.Clarification.SessionID = "imported-multi-repo-session"
issue.Clarification.SessionUserID = 1
- issue.Clarification.Answers = map[string]string{"scope": "保留导入回答"}
+ issue.Clarification.Summary = "保留导入回答"
return nil
}); err != nil {
t.Fatal(err)
@@ -157,7 +157,7 @@ func testImportTAPDRepositoryBranches(t *testing.T, st *repo.Store) {
branches[ids[1]] = "feature/web-v2"
payload["repositoryBranches"] = branches
changed := requestJSON[domain.Issue](t, h, http.MethodPost, "/api/issues/import-tapd", payload, http.StatusOK)
- if !maps.Equal(changed.RepositoryBranches, branches) || changed.Clarification.SessionID != "" || changed.Clarification.Answers["scope"] != "保留导入回答" {
+ if !maps.Equal(changed.RepositoryBranches, branches) || changed.Clarification.SessionID != "" || changed.Clarification.Summary != "保留导入回答" {
t.Fatalf("secondary repository branch change must invalidate reimported code context: %+v", changed)
}
payload["repositoryIds"] = ids[1:2]
diff --git a/internal/httpapi/issue_routes.go b/internal/httpapi/issue_routes.go
index d412567c..c5e2878f 100644
--- a/internal/httpapi/issue_routes.go
+++ b/internal/httpapi/issue_routes.go
@@ -50,44 +50,14 @@ func (h issuesHandlers) issueRuns(c *gin.Context, issue domain.Issue) {
c.JSON(200, runSummaries(issueRuns))
}
-func (h issuesHandlers) assessIssueClarification(c *gin.Context, issue domain.Issue) {
- var request struct {
- Answers map[string]string `json:"answers"`
- }
- if !decode(c, &request) {
- return
- }
- project, found := h.repo.Project(issue.ProjectID)
- if !found {
- c.JSON(400, map[string]string{"error": "project not found"})
- return
- }
- assessment := assessClarification(project.Clarification, request.Answers)
- if !issue.Clarification.StartedAt.IsZero() {
- assessment.StartedAt = issue.Clarification.StartedAt
- } else {
- assessment.StartedAt = time.Now().UTC()
- }
- assessment.Gated = true
- issue.Kind = "requirement"
- issue.Clarification = assessment
- if err := h.repo.PutIssue(issue); err != nil {
- respond(c, err)
- return
- }
- c.JSON(200, assessment)
-}
-
// clarificationSubmission is the clarify panel's save payload: a draft
// (Ready false), a final summary (Ready true), or a write-back retry.
type clarificationSubmission struct {
- Summary string `json:"summary"`
- Ready bool `json:"ready"`
- History []domain.ClarificationMessage `json:"history"`
- Questions []domain.ClarificationQuestion `json:"questions"`
- Dimensions map[string]int `json:"dimensions"`
- Missing []string `json:"missing"`
- Retry bool `json:"retry"`
+ Summary string `json:"summary"`
+ Ready bool `json:"ready"`
+ History []domain.ClarificationMessage `json:"history"`
+ Questions []domain.ClarificationQuestion `json:"questions"`
+ Retry bool `json:"retry"`
}
func (h issuesHandlers) submitIssueClarification(c *gin.Context, issue domain.Issue) {
@@ -95,8 +65,7 @@ func (h issuesHandlers) submitIssueClarification(c *gin.Context, issue domain.Is
if !decode(c, &request) {
return
}
- project, found := h.repo.Project(issue.ProjectID)
- issue, err := applyClarificationSubmission(issue, project, found, request, time.Now().UTC())
+ issue, err := applyClarificationSubmission(issue, request)
if err != nil {
respond(c, err)
return
@@ -138,11 +107,11 @@ func (h issuesHandlers) submitIssueClarification(c *gin.Context, issue domain.Is
}
// applyClarificationSubmission updates the issue's clarification state for a
-// submission: drafts only record progress, a final summary is scored against
-// the project's policy and appended to the description, and final/retry
+// submission: drafts only record progress, a final summary is appended to the
+// description, and final/retry
// submissions mark tracker write-back pending unless this exact summary was
// already written back.
-func applyClarificationSubmission(issue domain.Issue, project domain.Project, projectFound bool, request clarificationSubmission, now time.Time) (domain.Issue, error) {
+func applyClarificationSubmission(issue domain.Issue, request clarificationSubmission) (domain.Issue, error) {
summary := strings.TrimSpace(request.Summary)
if request.Ready && !request.Retry && summary == "" {
return issue, HTTPError{Status: http.StatusBadRequest, Message: "clarification summary is required"}
@@ -154,29 +123,6 @@ func applyClarificationSubmission(issue domain.Issue, project domain.Project, pr
assessment.Questions = request.Questions
if request.Ready {
assessment.Status = domain.ClarificationReady
- dimensions := clarificationRatingDimensions(issue, project, projectFound)
- score, rated := scoreClarificationDimensions(dimensions, request.Dimensions)
- assessment.Score = score
- assessment.Dimensions = rated
- assessment.Missing = trimClarificationMissing(request.Missing)
- if len(assessment.Missing) == 0 {
- for _, dim := range dimensions {
- if rated[dim.ID] < 100 {
- assessment.Missing = append(assessment.Missing, dim.ID)
- }
- }
- }
- if isBugStyleWorkItem(issue) {
- assessment.Passed = true
- } else {
- policy := domain.DefaultClarificationPolicy()
- if projectFound {
- policy = domain.EffectiveClarificationPolicy(project.Clarification)
- }
- assessment.Passed = domain.ClarificationPassed(policy, score)
- assessment.Gated = true
- }
- assessment.AssessedAt = now
promoteClarifiedIssueTodo(&issue)
} else {
assessment.Status = "in_progress"
diff --git a/internal/httpapi/issue_routes_test.go b/internal/httpapi/issue_routes_test.go
index da0d99cf..8f38632d 100644
--- a/internal/httpapi/issue_routes_test.go
+++ b/internal/httpapi/issue_routes_test.go
@@ -5,32 +5,30 @@ import (
"net/http"
"strings"
"testing"
- "time"
"agentflow/internal/domain"
)
func TestApplyClarificationSubmissionDraftAndFinal(t *testing.T) {
- now := time.Date(2026, 9, 30, 0, 0, 0, 0, time.UTC)
issue := domain.Issue{ID: "i", ProjectID: "p", Kind: "requirement", Description: "原始描述"}
- draft, err := applyClarificationSubmission(issue, domain.Project{}, false, clarificationSubmission{Summary: " 草稿 "}, now)
+ draft, err := applyClarificationSubmission(issue, clarificationSubmission{Summary: " 草稿 "})
if err != nil || draft.Clarification.Status != "in_progress" || draft.Clarification.Summary != "草稿" || draft.Description != "原始描述" {
t.Fatalf("draft should only record progress: %+v %v", draft.Clarification, err)
}
- _, err = applyClarificationSubmission(issue, domain.Project{}, false, clarificationSubmission{Ready: true}, now)
+ _, err = applyClarificationSubmission(issue, clarificationSubmission{Ready: true})
var he HTTPError
if !errors.As(err, &he) || he.Status != http.StatusBadRequest {
t.Fatalf("final submission without summary should be rejected, got %v", err)
}
- final, err := applyClarificationSubmission(issue, domain.Project{}, false, clarificationSubmission{Summary: "结论", Ready: true}, now)
+ final, err := applyClarificationSubmission(issue, clarificationSubmission{Summary: "结论", Ready: true})
if err != nil {
t.Fatal(err)
}
a := final.Clarification
- if a.Status != domain.ClarificationReady || !a.Gated || !a.AssessedAt.Equal(now) || a.WriteBackStatus != "pending" || a.WriteBackFingerprint == "" {
+ if a.Status != domain.ClarificationReady || a.WriteBackStatus != "pending" || a.WriteBackFingerprint == "" {
t.Fatalf("final submission state: %+v", a)
}
if !strings.Contains(final.Description, "结论") || !strings.HasPrefix(final.Description, "原始描述") {
@@ -39,20 +37,20 @@ func TestApplyClarificationSubmissionDraftAndFinal(t *testing.T) {
written := final
written.Clarification.WriteBackStatus = "succeeded"
- retried, err := applyClarificationSubmission(written, domain.Project{}, false, clarificationSubmission{Retry: true}, now)
+ retried, err := applyClarificationSubmission(written, clarificationSubmission{Retry: true})
if err != nil || retried.Clarification.WriteBackStatus != "succeeded" {
t.Fatalf("retrying an already written summary should not reset write-back: %+v %v", retried.Clarification, err)
}
- _, err = applyClarificationSubmission(issue, domain.Project{}, false, clarificationSubmission{Retry: true}, now)
+ _, err = applyClarificationSubmission(issue, clarificationSubmission{Retry: true})
if !errors.As(err, &he) {
t.Fatalf("retry without any saved summary should be rejected, got %v", err)
}
}
-func TestApplyClarificationSubmissionBugsAlwaysPass(t *testing.T) {
+func TestApplyClarificationSubmissionBugsFinish(t *testing.T) {
bug := domain.Issue{ID: "b", Kind: "issue"}
- out, err := applyClarificationSubmission(bug, domain.Project{}, false, clarificationSubmission{Summary: "复现步骤", Ready: true}, time.Now())
- if err != nil || !out.Clarification.Passed || out.Clarification.Gated {
+ out, err := applyClarificationSubmission(bug, clarificationSubmission{Summary: "复现步骤", Ready: true})
+ if err != nil || out.Clarification.Status != domain.ClarificationReady || out.Clarification.Gated {
t.Fatalf("bug-style items pass without gating: %+v %v", out.Clarification, err)
}
}
@@ -98,7 +96,7 @@ func TestIssueRoutesCoverRegisteredPaths(t *testing.T) {
t.Fatalf("%s: incomplete route", path)
}
}
- if len(issueRoutes) != 13 {
- t.Fatalf("expected 13 issue sub-routes, got %d", len(issueRoutes))
+ if len(issueRoutes) != 12 {
+ t.Fatalf("expected 12 issue sub-routes, got %d", len(issueRoutes))
}
}
diff --git a/internal/httpapi/issues.go b/internal/httpapi/issues.go
index 3cc5b31c..9a704ade 100644
--- a/internal/httpapi/issues.go
+++ b/internal/httpapi/issues.go
@@ -130,9 +130,6 @@ func (h issuesHandlers) importTAPD(c *gin.Context) {
return
}
stored, _ := h.repo.Issue(issue.ID)
- if stored.ID != "" {
- go h.stream.autoClarifyIssue(stored.ID)
- }
c.JSON(http.StatusOK, stored)
}
@@ -292,9 +289,8 @@ func (h issuesHandlers) issues(c *gin.Context) {
respond(c, err)
return
}
- // Import scoring and auto-clarify are owned by TAPD import / create,
- // not by issues_save. Binding SOP or repositories on a synced ticket
- // must not gate it as "待澄清".
+ // Clarification is optional: saving a ticket never scores it or starts
+ // a round. Binding SOP or repositories must not invent a status.
if found {
keepExistingTrackerBinding(&v, existing)
} else {
@@ -317,7 +313,6 @@ func (h issuesHandlers) issues(c *gin.Context) {
return
}
stored, _ = h.repo.Issue(stored.ID)
- go h.stream.autoClarifyIssue(stored.ID)
}
h.writeIssueView(c, 200, stored)
return
@@ -397,7 +392,7 @@ func mergeIssueEdit(v, existing domain.Issue) domain.Issue {
if v.PlaybookID == "" {
v.PlaybookID = existing.PlaybookID
}
- if v.Clarification.Score == 0 && !v.Clarification.Passed && len(v.Clarification.Answers) == 0 {
+ if v.Clarification.Status == "" && strings.TrimSpace(v.Clarification.Summary) == "" && len(v.Clarification.History) == 0 {
v.Clarification = existing.Clarification
}
v.Operations = append([]domain.IssueOperation(nil), existing.Operations...)
@@ -432,7 +427,6 @@ var issueRoutes = map[string]issueRoute{
"/api/issues/:id": {handle: issuesHandlers.issueDetail, methods: []string{http.MethodGet, http.MethodDelete}},
"/api/issues/:id/comments": {handle: issuesHandlers.addIssueComment, methods: []string{http.MethodPost}},
"/api/issues/:id/runs": {handle: issuesHandlers.issueRuns, methods: []string{http.MethodGet}},
- "/api/issues/:id/clarify": {handle: issuesHandlers.assessIssueClarification, methods: []string{http.MethodPost}},
"/api/issues/:id/clarification": {handle: issuesHandlers.submitIssueClarification, methods: []string{http.MethodPost}},
"/api/issues/:id/chat-clarify": {handle: issuesHandlers.chatClarifyIssue, methods: []string{http.MethodGet, http.MethodPost}},
"/api/issues/:id/chat-clarify/cancel": {handle: issuesHandlers.cancelChatClarifyIssue, methods: []string{http.MethodPost}},
@@ -613,10 +607,6 @@ func clarificationComment(issue domain.Issue, summary string) string {
return fmt.Sprintf("%s\n\n%s\n\n---\n来源:%s `%s`,由 LoopForge 基于当前描述和用户回答生成。", clarificationHeading, strings.TrimSpace(summary), source, issue.ID)
}
-func assessClarification(policy domain.ClarificationPolicy, answers map[string]string) domain.ClarificationAssessment {
- return domain.AssessClarificationAnswers(policy, answers)
-}
-
func (h issuesHandlers) bindIssueRepositories(v *domain.Issue) error {
ids := v.EffectiveRepositoryIDs()
if len(ids) == 0 {
diff --git a/internal/httpapi/issues_cases_test.go b/internal/httpapi/issues_cases_test.go
index a0100050..7e1e1729 100644
--- a/internal/httpapi/issues_cases_test.go
+++ b/internal/httpapi/issues_cases_test.go
@@ -53,30 +53,27 @@ func TestIssueRouteLifecycleBranches(t *testing.T) {
}
func TestClarificationSubmissionBranches(t *testing.T) {
- now := time.Now().UTC()
base := domain.Issue{ID: "i", Title: "Issue", Status: "analyzing", Kind: "requirement"}
- if _, err := applyClarificationSubmission(base, domain.Project{}, false, clarificationSubmission{Ready: true}, now); err == nil {
+ if _, err := applyClarificationSubmission(base, clarificationSubmission{Ready: true}); err == nil {
t.Fatal("empty final summary accepted")
}
- draft, err := applyClarificationSubmission(base, domain.Project{}, false, clarificationSubmission{Summary: "draft", Ready: false}, now)
+ draft, err := applyClarificationSubmission(base, clarificationSubmission{Summary: "draft", Ready: false})
if err != nil || draft.Clarification.Status != "in_progress" {
t.Fatalf("draft: %+v %v", draft, err)
}
- final, err := applyClarificationSubmission(base, domain.Project{}, false, clarificationSubmission{
- Summary: "summary", Ready: true, Dimensions: map[string]int{"goal": 100}, Missing: []string{" x ", "", "x"},
- }, now)
+ final, err := applyClarificationSubmission(base, clarificationSubmission{Summary: "summary", Ready: true})
if err != nil || final.Clarification.Status != domain.ClarificationReady || !strings.Contains(final.Description, "summary") {
t.Fatalf("final: %+v %v", final, err)
}
retryBase := final
retryBase.Clarification.Summary = ""
- if _, err := applyClarificationSubmission(retryBase, domain.Project{}, false, clarificationSubmission{Retry: true}, now); err == nil {
+ if _, err := applyClarificationSubmission(retryBase, clarificationSubmission{Retry: true}); err == nil {
t.Fatal("retry without summary accepted")
}
bug := base
bug.Kind = "issue"
- bugFinal, err := applyClarificationSubmission(bug, domain.Project{}, true, clarificationSubmission{Summary: "bug", Ready: true}, now)
- if err != nil || !bugFinal.Clarification.Passed {
+ bugFinal, err := applyClarificationSubmission(bug, clarificationSubmission{Summary: "bug", Ready: true})
+ if err != nil || bugFinal.Clarification.Status != domain.ClarificationReady {
t.Fatalf("bug clarification: %+v %v", bugFinal, err)
}
for _, issue := range []domain.Issue{
@@ -96,7 +93,7 @@ func TestIssuesMoreDirectHelpers(t *testing.T) {
RepositoryID: "repo-a", BaseBranch: "feature/x", Kind: "requirement",
AssigneeID: "agent", AssigneeType: "agent", AssigneeUserID: 7,
WorkflowID: "wf", SOPBindings: []domain.IssueSOPBinding{{WorkflowID: "wf"}},
- PlaybookID: "book", Clarification: domain.ClarificationAssessment{Score: 80, Passed: true},
+ PlaybookID: "book", Clarification: domain.ClarificationAssessment{Summary: "已澄清", Status: domain.ClarificationReady},
Operations: []domain.IssueOperation{{Action: "create"}},
}
merged := mergeIssueEdit(domain.Issue{ID: "existing"}, existing)
@@ -405,9 +402,7 @@ func TestIssuesMoreRouteBranches(t *testing.T) {
{http.MethodPut, "/api/issues/cvb-more-route", nil, http.StatusNotFound},
{http.MethodPost, "/api/issues/cvb-more-route/comments", "bad", http.StatusBadRequest},
{http.MethodGet, "/api/issues/cvb-more-route/runs", nil, http.StatusOK},
- {http.MethodPost, "/api/issues/cvb-more-route/clarify", "bad", http.StatusBadRequest},
- {http.MethodPost, "/api/issues/cvb-more-orphan/clarify", map[string]any{"answers": map[string]string{}}, http.StatusBadRequest},
- {http.MethodPost, "/api/issues/cvb-more-route/clarify", map[string]any{"answers": map[string]string{"goal": "enough"}}, http.StatusOK},
+ {http.MethodPost, "/api/issues/cvb-more-route/clarify", map[string]any{"answers": map[string]string{"goal": "enough"}}, http.StatusNotFound},
{http.MethodPost, "/api/issues/cvb-more-route/clarification", "bad", http.StatusBadRequest},
{http.MethodPost, "/api/issues/cvb-more-retry/clarification", map[string]any{"retry": true}, http.StatusOK},
{http.MethodPut, "/api/issues/cvb-more-route/sops", "bad", http.StatusBadRequest},
@@ -513,8 +508,8 @@ func TestIssuesMoreForcedPersistenceError(t *testing.T) {
if err := f.s.DB.Exec(`CREATE TRIGGER cvb_more_reject_issue_update BEFORE UPDATE ON issues BEGIN SELECT RAISE(FAIL, 'forced issue update failure'); END`).Error; err != nil {
t.Fatal(err)
}
- rec := cvBRequest(t, f, http.MethodPost, "/api/issues/"+issue.ID+"/clarify", map[string]any{
- "answers": map[string]string{"goal": "answer"},
+ rec := cvBRequest(t, f, http.MethodPost, "/api/issues/"+issue.ID+"/clarification", map[string]any{
+ "summary": "answer",
}, true)
if rec.Code != http.StatusBadRequest {
t.Fatalf("forced persistence error = %d: %s", rec.Code, rec.Body.String())
diff --git a/internal/httpapi/issues_close_test.go b/internal/httpapi/issues_close_test.go
index 9af8cba9..fe52c3dc 100644
--- a/internal/httpapi/issues_close_test.go
+++ b/internal/httpapi/issues_close_test.go
@@ -1,6 +1,7 @@
package httpapi
import (
+ "context"
"net/http"
"net/http/httptest"
"path/filepath"
@@ -136,6 +137,13 @@ func TestCloseIssueRejectsActiveWork(t *testing.T) {
issue := domain.Issue{ID: "close-boundary", ProjectID: "platform", Title: "closure boundary", Status: "backlog"}
if status == "analyzing" {
issue.Clarification.Status = "analyzing"
+ // Startup recovery resumes the interrupted round; keep it
+ // running so the issue stays busy for the whole check.
+ setClarifyExecForTest(func(ctx context.Context, _ domain.Issue, _ chatClarifyRequest, _ func(string, any)) (any, string, map[string]any, error) {
+ <-ctx.Done()
+ return nil, "", nil, ctx.Err()
+ })
+ t.Cleanup(func() { setClarifyExecForTest(nil) })
}
if err := st.PutIssue(issue); err != nil {
t.Fatal(err)
diff --git a/internal/httpapi/issues_test.go b/internal/httpapi/issues_test.go
index 4cb08b72..bc056f62 100644
--- a/internal/httpapi/issues_test.go
+++ b/internal/httpapi/issues_test.go
@@ -93,7 +93,7 @@ func TestDispatchTAPDIssuePutsStoryIdentityInInput(t *testing.T) {
issue := domain.Issue{
ID: "tapd-1010000000100001887", ProjectID: "platform", Kind: "requirement", Source: "tapd",
Title: "在soul广场页面新增一个banner", Description: "纯前端写死", Status: "todo",
- WorkflowID: "tapd-identity", Clarification: domain.ClarificationAssessment{Passed: true, Score: 90, Status: "ready"},
+ WorkflowID: "tapd-identity", Clarification: domain.ClarificationAssessment{Status: "ready"},
ExternalRef: &domain.ExternalRef{Source: "tapd", ExternalID: "1010000000100001887", ExternalType: "story", ExternalURL: "https://tapd.example.com/tapd_fe/10000000/story/detail/1010000000100001887"},
}
if err := s.PutIssue(issue); err != nil {
@@ -1366,7 +1366,7 @@ func TestMergedTAPDDeliveryRequiresExplicitReopen(t *testing.T) {
}
e := engine.New(s, runtime.NewManager(filepath.Join(root, "workspaces")))
h := New(s, e, tracker.NewService(), "", "")
- issue := domain.Issue{ID: "tapd-merged", ProjectID: "platform", Source: "tapd", Kind: "requirement", Title: "Delivered", Status: "done", WorkflowID: wf.ID, LatestTaskID: "task-old", DeliveryState: "merged", DeliveryMRURL: "https://git.example.com/org/repo/merge_requests/9", AutomationState: "ignored", Clarification: domain.ClarificationAssessment{Passed: true, Score: 100}}
+ issue := domain.Issue{ID: "tapd-merged", ProjectID: "platform", Source: "tapd", Kind: "requirement", Title: "Delivered", Status: "done", WorkflowID: wf.ID, LatestTaskID: "task-old", DeliveryState: "merged", DeliveryMRURL: "https://git.example.com/org/repo/merge_requests/9", AutomationState: "ignored"}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
@@ -1395,7 +1395,7 @@ func TestMergedTAPDDeliveryRequiresExplicitReopen(t *testing.T) {
}
}
-func TestRequirementMustPassConfigurableClarificationBeforeDispatch(t *testing.T) {
+func TestRequirementDispatchesWithoutClarificationGate(t *testing.T) {
root := t.TempDir()
s, err := repo.OpenTest()
if err != nil {
@@ -1406,34 +1406,25 @@ func TestRequirementMustPassConfigurableClarificationBeforeDispatch(t *testing.T
if err := s.PutWorkflow(wf); err != nil {
t.Fatal(err)
}
- h := New(s, engine.New(s, runtime.NewManager(filepath.Join(root, "workspaces"))), tracker.NewService(), "", "")
- if err := s.PutIssue(domain.Issue{ID: "req-gated", ProjectID: "platform", Kind: "requirement", Title: "Build requirement", AssigneeType: "agent", AssigneeID: "developer", WorkflowID: wf.ID, Clarification: domain.ClarificationAssessment{Gated: true}}); err != nil {
+ e := engine.New(s, runtime.NewManager(filepath.Join(root, "workspaces")))
+ h := New(s, e, tracker.NewService(), "", "")
+ // Legacy imports still carry gated/needs_user; neither may block the SOP.
+ if err := s.PutIssue(domain.Issue{ID: "req-gated", ProjectID: "platform", Kind: "requirement", Title: "Build requirement", AssigneeType: "agent", AssigneeID: "developer", WorkflowID: wf.ID, Clarification: domain.ClarificationAssessment{Gated: true, Status: domain.ClarificationNeedsUser}}); err != nil {
t.Fatal(err)
}
- issue, _ := s.Issue("req-gated")
- requestJSON[map[string]any](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/dispatch", map[string]any{}, http.StatusConflict)
- partial := requestJSON[domain.ClarificationAssessment](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/clarify", map[string]any{"answers": map[string]string{"goal": "short"}}, http.StatusOK)
- if partial.Passed || partial.Score >= 80 {
- t.Fatalf("partial clarification unexpectedly passed: %+v", partial)
- }
- long := strings.Repeat("完整且可验证的需求信息", 8)
- passed := requestJSON[domain.ClarificationAssessment](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/clarify", map[string]any{"answers": map[string]string{"goal": long, "user": long, "scope": long, "acceptance": long, "constraints": long}}, http.StatusOK)
- if !passed.Passed || passed.Score != 100 {
- t.Fatalf("complete clarification did not pass: %+v", passed)
+ rec := httptest.NewRecorder()
+ h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/api/issues/req-gated/clarify", strings.NewReader(`{"answers":{}}`)))
+ if rec.Code != http.StatusNotFound {
+ t.Fatalf("score endpoint must be gone, got %d", rec.Code)
}
- task := requestJSON[domain.Task](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/dispatch", map[string]any{}, http.StatusCreated)
- deadline := time.Now().Add(2 * time.Second)
- for time.Now().Before(deadline) {
- run, _ := s.Run(task.RunID)
- if run.Status == "waiting" {
- return
- }
- time.Sleep(10 * time.Millisecond)
+ task := requestJSON[domain.Task](t, h, http.MethodPost, "/api/issues/req-gated/dispatch", map[string]any{}, http.StatusCreated)
+ t.Cleanup(func() { _ = e.Cancel(task.RunID) })
+ if task.RunID == "" {
+ t.Fatal("unclarified requirement must dispatch")
}
- t.Fatal("clarified requirement run did not settle")
}
-func TestScheduledDispatchAlsoRequiresClarification(t *testing.T) {
+func TestScheduledDispatchDoesNotRequireClarification(t *testing.T) {
root := t.TempDir()
s, err := repo.OpenTest()
if err != nil {
@@ -1446,16 +1437,17 @@ func TestScheduledDispatchAlsoRequiresClarification(t *testing.T) {
}
if err := s.PutIssue(domain.Issue{
ID: "req-sched-gate", ProjectID: "platform", Kind: "requirement", Title: "Thin TAPD",
- WorkflowID: wf.ID, Clarification: domain.ClarificationAssessment{Score: 20, Status: domain.ClarificationNeedsUser, Gated: true},
+ WorkflowID: wf.ID, Clarification: domain.ClarificationAssessment{Status: domain.ClarificationNeedsUser, Gated: true},
}); err != nil {
t.Fatal(err)
}
- d := &deps{repo: s, engine: engine.New(s, runtime.NewManager(filepath.Join(root, "workspaces"))), sync: tracker.NewService()}
- _, err = dispatchIssue(d, dispatchRequest{IssueID: "req-sched-gate", WorkflowID: wf.ID, ScheduleJobID: "job-1"})
- httpErr, ok := err.(HTTPError)
- if !ok || httpErr.Status != http.StatusConflict || !strings.Contains(httpErr.Message, "澄清未达标") {
- t.Fatalf("scheduled dispatch must stay gated: %v", err)
+ e := engine.New(s, runtime.NewManager(filepath.Join(root, "workspaces")))
+ d := &deps{repo: s, engine: e, sync: tracker.NewService()}
+ task, err := dispatchIssue(d, dispatchRequest{IssueID: "req-sched-gate", WorkflowID: wf.ID, ScheduleJobID: "job-1"})
+ if err != nil {
+ t.Fatalf("scheduled dispatch must not be gated: %v", err)
}
+ t.Cleanup(func() { _ = e.Cancel(task.RunID) })
}
func TestSyncedRequirementCanDispatchWithoutClarification(t *testing.T) {
@@ -1471,7 +1463,7 @@ func TestSyncedRequirementCanDispatchWithoutClarification(t *testing.T) {
}
if err := s.PutIssue(domain.Issue{
ID: "req-sync", ProjectID: "platform", Kind: "requirement", Source: "tapd", Title: "mq_flush_dns CMQ SDK",
- WorkflowID: wf.ID, Clarification: domain.ClarificationAssessment{Score: 0, Status: domain.ClarificationNeedsUser},
+ WorkflowID: wf.ID, Clarification: domain.ClarificationAssessment{Status: domain.ClarificationNeedsUser},
}); err != nil {
t.Fatal(err)
}
@@ -1487,7 +1479,7 @@ func TestSyncedRequirementCanDispatchWithoutClarification(t *testing.T) {
}
}
-func TestReadyClarificationCanDispatchBelowThreshold(t *testing.T) {
+func TestReadyClarificationCanDispatch(t *testing.T) {
root := t.TempDir()
s, err := repo.OpenTest()
if err != nil {
@@ -1502,7 +1494,7 @@ func TestReadyClarificationCanDispatchBelowThreshold(t *testing.T) {
ID: "req-ready-low", ProjectID: "platform", Kind: "requirement", Title: "Low score but clarified",
WorkflowID: wf.ID,
Clarification: domain.ClarificationAssessment{
- Gated: true, Score: 76, Passed: false, Status: domain.ClarificationReady, Summary: "已确认 insert/delete 语义",
+ Gated: true, Status: domain.ClarificationReady, Summary: "已确认 insert/delete 语义",
},
}); err != nil {
t.Fatal(err)
@@ -1515,7 +1507,7 @@ func TestReadyClarificationCanDispatchBelowThreshold(t *testing.T) {
}
t.Cleanup(func() { _ = e.Cancel(task.RunID) })
if task.RunID == "" {
- t.Fatal("finished clarification must dispatch even below 80")
+ t.Fatal("finished clarification must dispatch")
}
}
@@ -1551,7 +1543,7 @@ func TestExistingIssueClarificationDoesNotStartOrBlockSOP(t *testing.T) {
"summary": "复现条件和预期行为已经确认", "ready": true,
"history": []map[string]string{{"role": "user", "content": "仅在首次加载时发生"}},
}, http.StatusOK)
- if !updated.Clarification.Passed || updated.Clarification.Status != "ready" || updated.Clarification.WriteBackStatus != "skipped" {
+ if updated.Clarification.Status != "ready" || updated.Clarification.WriteBackStatus != "skipped" {
t.Fatalf("unexpected clarification: %+v", updated.Clarification)
}
if !strings.Contains(updated.Description, "复现条件和预期行为已经确认") {
@@ -1573,50 +1565,7 @@ func TestExistingIssueClarificationDoesNotStartOrBlockSOP(t *testing.T) {
t.Cleanup(func() { _ = e.Cancel(task.RunID) })
}
-func TestClarificationScoreIsWeightedAndNeverGatesDispatch(t *testing.T) {
- root := t.TempDir()
- s, err := repo.OpenTest()
- if err != nil {
- t.Fatal(err)
- }
- t.Cleanup(func() { s.Close() })
- wf := domain.WorkflowDefinition{ID: "issue-flow", Name: "Issue flow", SandboxProfileID: "local", Nodes: []domain.WorkflowNode{{ID: "approval", Name: "Approval", Type: "approval", MaxAttempts: 1}}}
- if err := s.PutWorkflow(wf); err != nil {
- t.Fatal(err)
- }
- issue := domain.Issue{ID: "gf-rated", ProjectID: "platform", Kind: "issue", Source: "gongfeng", Title: "partial info", WorkflowID: wf.ID}
- if err := s.PutIssue(issue); err != nil {
- t.Fatal(err)
- }
- e := engine.New(s, runtime.NewManager(filepath.Join(root, "workspaces")))
- h := New(s, e, tracker.NewService(), "", "")
- // Bug-style weights are 25/20/25/20/10; "acceptance" is left unrated on
- // purpose and must count as zero rather than being dropped.
- updated := requestJSON[domain.Issue](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/clarification", map[string]any{
- "summary": "现象和期望行为已确认,验收标准仍缺", "ready": true,
- "dimensions": map[string]int{"phenomenon": 100, "impact": 50, "expected": 80, "constraints": 100},
- "missing": []string{"验收标准还没定", " "},
- }, http.StatusOK)
- if updated.Clarification.Score != 65 {
- t.Fatalf("weighted score = %d, want 65 (%+v)", updated.Clarification.Score, updated.Clarification.Dimensions)
- }
- if got, ok := updated.Clarification.Dimensions["acceptance"]; !ok || got != 0 {
- t.Fatalf("unrated dimension should be stored as 0: %+v", updated.Clarification.Dimensions)
- }
- if len(updated.Clarification.Missing) != 1 || updated.Clarification.Missing[0] != "验收标准还没定" {
- t.Fatalf("missing items not trimmed: %+v", updated.Clarification.Missing)
- }
- if !updated.Clarification.Passed {
- t.Fatalf("bug-style clarification still marks the item clarified: %+v", updated.Clarification)
- }
- task := requestJSON[domain.Task](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/dispatch", map[string]any{}, http.StatusCreated)
- if task.RunID == "" {
- t.Fatal("low clarification score must not block dispatch")
- }
- t.Cleanup(func() { _ = e.Cancel(task.RunID) })
-}
-
-func TestRequirementChatClarificationEmptyRatingsDoNotPass(t *testing.T) {
+func TestRequirementClarificationFinishesWithoutScore(t *testing.T) {
root := t.TempDir()
s, err := repo.OpenTest()
if err != nil {
@@ -1636,12 +1585,6 @@ func TestRequirementChatClarificationEmptyRatingsDoNotPass(t *testing.T) {
updated := requestJSON[domain.Issue](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/clarification", map[string]any{
"summary": "还缺验收和范围", "ready": true,
}, http.StatusOK)
- if updated.Clarification.Passed || updated.Clarification.Score != 0 {
- t.Fatalf("empty ratings must not pass: %+v", updated.Clarification)
- }
- if len(updated.Clarification.Dimensions) == 0 {
- t.Fatal("empty ratings must still store every dimension as 0")
- }
if updated.Clarification.Status != domain.ClarificationReady {
t.Fatalf("status=%s", updated.Clarification.Status)
}
@@ -1650,7 +1593,7 @@ func TestRequirementChatClarificationEmptyRatingsDoNotPass(t *testing.T) {
}
task := requestJSON[domain.Task](t, h, http.MethodPost, "/api/issues/"+issue.ID+"/dispatch", map[string]any{}, http.StatusCreated)
if task.RunID == "" {
- t.Fatal("ready clarification must dispatch even with empty ratings")
+ t.Fatal("ready clarification must dispatch")
}
t.Cleanup(func() { _ = e.Cancel(task.RunID) })
}
@@ -1781,13 +1724,9 @@ func TestImportTAPDIssueFromURL(t *testing.T) {
if imported.AssigneeUserID != owner.ID {
t.Fatalf("assignee=%d want project owner %d when TAPD handler is missing", imported.AssigneeUserID, owner.ID)
}
- if imported.Clarification.Passed || imported.Clarification.Status != domain.ClarificationNeedsUser || !imported.Clarification.Gated {
- t.Fatalf("imported clarification=%+v", imported.Clarification)
- }
- if len(imported.Clarification.Dimensions) == 0 {
- t.Fatal("import must persist per-dimension scores")
+ if imported.Clarification.Status != "" || imported.Clarification.Gated {
+ t.Fatalf("import must not score or auto-start clarification: %+v", imported.Clarification)
}
- requestJSON[map[string]any](t, h, http.MethodPost, "/api/issues/"+imported.ID+"/dispatch", map[string]any{}, http.StatusConflict)
}
func TestImportTAPDIssueSaveKeepsExternalBinding(t *testing.T) {
@@ -1854,8 +1793,6 @@ func TestSaveAfterClarificationDoesNotRecreateOrDeleteTAPDIssue(t *testing.T) {
ExternalType: "story",
},
Clarification: domain.ClarificationAssessment{
- Score: 88,
- Passed: true,
Gated: true,
Status: domain.ClarificationReady,
Summary: "已补齐验收标准",
@@ -1889,7 +1826,7 @@ func TestSaveAfterClarificationDoesNotRecreateOrDeleteTAPDIssue(t *testing.T) {
if saved.Title != "澄清后改标题" {
t.Fatalf("title=%q", saved.Title)
}
- if !saved.Clarification.Passed || saved.Clarification.Summary != "已补齐验收标准" {
+ if saved.Clarification.Status != domain.ClarificationReady || saved.Clarification.Summary != "已补齐验收标准" {
t.Fatalf("clarification wiped on save: %+v", saved.Clarification)
}
}
@@ -1932,7 +1869,7 @@ func TestIssuesSaveDoesNotGateSyncedTAPDRequirement(t *testing.T) {
if saved.WorkflowID != "demodns-issue-fix" || saved.RepositoryID != "repo-new-demodns" {
t.Fatalf("binding not saved: workflow=%q repo=%q", saved.WorkflowID, saved.RepositoryID)
}
- if saved.Clarification.Gated || saved.Clarification.Score != 0 || saved.Clarification.Status != "" {
+ if saved.Clarification.Gated || saved.Clarification.Status != "" {
t.Fatalf("synced TAPD save must not import-score: %+v", saved.Clarification)
}
}
diff --git a/internal/httpapi/native_prompt_test.go b/internal/httpapi/native_prompt_test.go
index 29b4550d..a79aa0c4 100644
--- a/internal/httpapi/native_prompt_test.go
+++ b/internal/httpapi/native_prompt_test.go
@@ -5,8 +5,6 @@ import (
"errors"
"strings"
"testing"
-
- "agentflow/internal/domain"
)
func TestNativePromptsAreToolFirst(t *testing.T) {
@@ -15,13 +13,13 @@ func TestNativePromptsAreToolFirst(t *testing.T) {
assistantScheduledSystemPromptText(assistantExecMode{AutoWrite: true}),
assistantScheduledSystemPromptText(assistantExecMode{AutoWrite: true, DeferSOP: true}),
scheduledAssistantPrompt(assistantTask{Name: "n", Prompt: "p", ProjectID: "platform"}, assistantExecMode{AutoWrite: true}),
- clarifySystemPrompt("intro", "mcp-step", "focus", "rating"),
+ clarifySystemPrompt("intro", "mcp-step", "focus"),
clarifyNativeRetryPrompt(),
assistantNativeRetryPrompt(),
agentToolInstructions(AgentToolClarify),
agentToolInstructions(AgentToolAssistant),
agentToolInstructions(AgentToolScheduled),
- clarifyResumeTurnPrompt("hello"),
+ clarifyResumeTurnPrompt("标题", "hello", 4),
}
forbidden := []string{
"不要再打印",
@@ -54,18 +52,30 @@ func TestNativePromptsAreToolFirst(t *testing.T) {
if prompt := assistantSystemPromptText(); !strings.Contains(prompt, "mode=direct") || !strings.Contains(prompt, "targetBranch") {
t.Fatalf("native assistant prompt must teach mode=direct for shared branches:\n%s", prompt)
}
- if !strings.Contains(clarifySystemPrompt("i", "m", "f", "r"), "submit_clarification") {
+ if !strings.Contains(clarifySystemPrompt("i", "m", "f"), "submit_clarification") {
t.Fatal("native clarify prompt must require submit_clarification")
}
}
-func TestClarificationRatingPromptAlwaysAsksAssessment(t *testing.T) {
- prompt := clarificationRatingPrompt(domain.DefaultClarificationPolicy().Dimensions)
- for _, want := range []string{"每轮都必须返回 assessment", "ready=false 时也要打分", "才把 ready 设为 true", "goal"} {
- if !strings.Contains(prompt, want) {
- t.Fatalf("rating prompt missing %q:\n%s", want, prompt)
+func TestClarifyPromptsAnchorScopeWithoutScoring(t *testing.T) {
+ system := clarifySystemPrompt("i", "m", "f")
+ for _, want := range []string{"范围规则", "就是本次范围的边界", "不要提出会扩大范围的问题或选项", "不在本次范围", "没有阻塞开工的缺口就设 ready=true"} {
+ if !strings.Contains(system, want) {
+ t.Fatalf("system prompt missing %q:\n%s", want, system)
+ }
+ }
+ for _, banned := range []string{"assessment", "打分", "0-100", "主要改哪个"} {
+ if strings.Contains(system, banned) || strings.Contains(clarifyNativeRetryPrompt(), banned) {
+ t.Fatalf("clarify prompts must not mention %q", banned)
}
}
+ resume := clarifyResumeTurnPrompt("国际站绑定对齐", "顺便把国内站也改了", 1)
+ if !strings.Contains(resume, "「国际站绑定对齐」") || !strings.Contains(resume, "不在本次范围") || strings.Contains(resume, "已经澄清了") {
+ t.Fatalf("resume prompt must re-anchor on the title:\n%s", resume)
+ }
+ if late := clarifyResumeTurnPrompt("x", "y", 3); !strings.Contains(late, "已经澄清了 3 轮") || !strings.Contains(late, "ready=true") {
+ t.Fatalf("resume prompt must push for a conclusion after several rounds:\n%s", late)
+ }
}
func TestNativeShouldRetryTerminal(t *testing.T) {
diff --git a/internal/httpapi/protocol_cases_test.go b/internal/httpapi/protocol_cases_test.go
index c78d8f84..fddd3505 100644
--- a/internal/httpapi/protocol_cases_test.go
+++ b/internal/httpapi/protocol_cases_test.go
@@ -232,7 +232,6 @@ func TestClarifyResultCoercionAndPersistence(t *testing.T) {
_ = st.PutProject(domain.Project{ID: "clarify-p", Name: "P"})
_ = st.PutIssue(domain.Issue{ID: "clarify-i", ProjectID: "clarify-p", Title: "Need", Description: "Original"})
h := &streamHandlers{deps: &deps{repo: st}}
- ready.Assessment.Dimensions = map[string]int{"goal": 100}
saved, err := h.saveClarificationAssessment("clarify-i", ready)
if err != nil || saved.Clarification.Status != domain.ClarificationReady || !strings.Contains(saved.Description, "complete") {
t.Fatalf("ready save=%+v %v", saved.Clarification, err)
@@ -241,7 +240,6 @@ func TestClarifyResultCoercionAndPersistence(t *testing.T) {
Questions: []domain.ClarificationQuestion{{ID: "q", Question: "Pick", Options: []string{"A", "B"}}},
raw: map[string]any{"ready": false, "questions": []any{}},
}
- pending.Assessment.Dimensions = map[string]int{"goal": 20}
saved, err = h.saveClarificationAssessment("clarify-i", pending)
if err != nil || saved.Clarification.Status != domain.ClarificationInProgress {
t.Fatalf("pending save=%+v %v", saved.Clarification, err)
@@ -337,7 +335,7 @@ func TestWorkbenchDeckAndClarifySessionHelpers(t *testing.T) {
if captureClarifySessionID(`{"session_id":" abc "}`) != "abc" || captureClarifySessionID("bad") != "" {
t.Fatal("session capture")
}
- if !strings.Contains(clarifyResumeTurnPrompt(""), "继续澄清") || !isClarifyProtocolObject(map[string]any{"ready": true}) || isClarifyProtocolObject("x") {
+ if !strings.Contains(clarifyResumeTurnPrompt("", "", 0), "继续澄清") || !isClarifyProtocolObject(map[string]any{"ready": true}) || isClarifyProtocolObject("x") {
t.Fatal("clarify protocol helpers")
}
for msg, want := range map[string]string{
diff --git a/internal/httpapi/server.go b/internal/httpapi/server.go
index 5a898cd1..bca13003 100644
--- a/internal/httpapi/server.go
+++ b/internal/httpapi/server.go
@@ -174,9 +174,6 @@ func newWithNotifications(s *repo.Store, e *engine.Engine, syncSvc *tracker.Serv
if syncSvc != nil {
e.MergeIntoBranch = syncSvc.EnsureAndMergeBranchMR
e.FindBranchMR = syncSvc.FindBranchMR
- syncSvc.OnRequirementImported = func(issue domain.Issue) {
- go stream.autoClarifyIssue(issue.ID)
- }
}
// Wake long-polling CLI runners the moment the engine queues a task.
e.SetRunnerDispatchNotify(func(provider string) { api.runners.runnerWaiters.notify([]string{provider}) })
@@ -351,7 +348,6 @@ func newWithNotifications(s *repo.Store, e *engine.Engine, syncSvc *tracker.Serv
g.Any("/api/issues/:id", api.issues.issue)
g.Any("/api/issues/:id/comments", api.issues.issue)
g.Any("/api/issues/:id/runs", api.issues.issue)
- g.Any("/api/issues/:id/clarify", api.issues.issue)
g.Any("/api/issues/:id/clarification", api.issues.issue)
g.Any("/api/issues/:id/chat-clarify", api.issues.issue)
g.Any("/api/issues/:id/chat-clarify/cancel", api.issues.issue)
diff --git a/internal/httpapi/skillhub_market_test.go b/internal/httpapi/skillhub_market_test.go
index 75d91c61..2d2bac4b 100644
--- a/internal/httpapi/skillhub_market_test.go
+++ b/internal/httpapi/skillhub_market_test.go
@@ -211,7 +211,7 @@ func newSkillhubTestServer(t *testing.T, apiKey string) (*fakeSkillhub, *repo.St
t.Setenv("SKILLHUB_BASE_URL", f.api.URL)
t.Setenv("SKILLHUB_API_KEY", apiKey)
s := newSkillFileServer(t)
- if err := s.PutProject(domain.Project{ID: "other", Key: "OTH", Name: "数据中台", WorkflowID: "requirement-development-production", Clarification: domain.DefaultClarificationPolicy()}); err != nil {
+ if err := s.PutProject(domain.Project{ID: "other", Key: "OTH", Name: "数据中台", WorkflowID: "requirement-development-production"}); err != nil {
t.Fatal(err)
}
return f, s, skillFileHandler(t, s)
diff --git a/internal/httpapi/stream.go b/internal/httpapi/stream.go
index 30c61964..68168d33 100644
--- a/internal/httpapi/stream.go
+++ b/internal/httpapi/stream.go
@@ -361,6 +361,25 @@ func (h *streamHandlers) runChatClarify(c *gin.Context, issue domain.Issue, requ
h.handleComposerClarify(c, issue, request)
}
+// isBugStyleWorkItem reports whether the work item is a bug (Gongfeng issue)
+// rather than a requirement; the clarification focus differs.
+func isBugStyleWorkItem(issue domain.Issue) bool {
+ return strings.EqualFold(issue.Source, "gongfeng") || strings.EqualFold(issue.Kind, "issue")
+}
+
+func clarifyAssistantRounds(history []struct {
+ Role string `json:"role"`
+ Content string `json:"content"`
+}) int {
+ n := 0
+ for _, item := range history {
+ if strings.EqualFold(strings.TrimSpace(item.Role), "assistant") {
+ n++
+ }
+ }
+ return n
+}
+
func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue, request chatClarifyRequest, emit func(event string, payload any)) (any, string, map[string]any, error) {
if emit == nil {
emit = func(string, any) {}
@@ -373,13 +392,11 @@ func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue,
extras := clarifyRequestTexts(request)
hydrateClarifyIssueFromText(&issue, extras...)
workItemType := "需求"
- focus := "目标、范围、用户场景、约束和可验证的验收标准"
+ focus := "这条需求具体要改什么、改到什么程度、怎样验收"
if isBugStyleWorkItem(issue) {
workItemType = "Issue"
- focus = "实际现象、复现条件、期望行为、影响范围、约束和可验证的验收标准"
+ focus = "实际现象、复现条件、期望行为和怎样验证已修复"
}
- ratingProject, ratingProjectFound := h.repo.Project(issue.ProjectID)
- ratingPrompt := clarificationRatingPrompt(clarificationRatingDimensions(issue, ratingProject, ratingProjectFound))
modelCtx, cancelModel := context.WithCancel(ctx)
defer cancelModel()
var toolSession *AgentToolSession
@@ -404,7 +421,7 @@ func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue,
mcpStep = "2. 若下文列出了可用 MCP 工具:描述或对话里出现外部需求、Issue 或文档链接时必须先调用对应工具读取,并同步读评论。没有链接不要为了找原单去 list。不要声称看不到评论或文档。"
}
}
- systemPrompt := clarifySystemPrompt(intro, mcpStep, focus, ratingPrompt)
+ systemPrompt := clarifySystemPrompt(intro, mcpStep, focus)
var prompt strings.Builder
prompt.WriteString(systemPrompt)
prompt.WriteString("\n\n## 需求\n标题:")
@@ -432,7 +449,8 @@ func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue,
prompt.WriteString(request.Message)
prompt.WriteString("\n")
}
- prompt.WriteString("\n请基于以上对话继续澄清,完成后调用 submit_clarification。")
+ prompt.WriteString(clarifyRoundBudgetHint(clarifyAssistantRounds(request.History)))
+ prompt.WriteString("\n请基于以上对话继续澄清,只围绕「## 需求」本身,完成后调用 submit_clarification。")
cbPath, cbErr := resolveCodeBuddyBin()
if cbErr != nil {
return nil, "", nil, cbErr
@@ -579,7 +597,7 @@ func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue,
fmt.Fprintf(&b, "\n- %s: 目录 %s", a.name, a.dir)
}
}
- b.WriteString("\n澄清问题与 summary 需覆盖以上所有仓库的协同改动,分别说明每个仓库各自需要什么。")
+ b.WriteString("\n只澄清本需求实际要改动的仓库;summary 分别说明涉及的每个仓库各自需要什么,不涉及的仓库不必展开。")
for _, a := range analyses {
if a.analyzed && a.dirName != "" {
continue
@@ -593,7 +611,7 @@ func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue,
prompt.WriteString(b.String())
} else if len(analyzedRepos) == 1 && len(analyses) > 1 {
a := analyzedRepos[0]
- prompt.WriteString(fmt.Sprintf("\n\n## 多仓库范围\n本次需求还涉及其他仓库,但仅 %s 成功检出(当前工作目录),其余未能分析,请勿声称已阅读其代码。澄清问题与 summary 需说明多仓库协同的范围。", a.name))
+ prompt.WriteString(fmt.Sprintf("\n\n## 多仓库范围\n本次需求还涉及其他仓库,但仅 %s 成功检出(当前工作目录),其余未能分析,请勿声称已阅读其代码。summary 需说明本需求涉及的其他仓库各自需要什么。", a.name))
}
if mcpHint := h.clarifyMCPInstructionsFor(issue, responsible, len(request.History) > 0, extras...); mcpHint != "" {
prompt.WriteString(mcpHint)
@@ -607,7 +625,7 @@ func (h *streamHandlers) executeClarify(ctx context.Context, issue domain.Issue,
}
turnPrompt := userMsg
if resume {
- turnPrompt = clarifyResumeTurnPrompt(request.Message)
+ turnPrompt = clarifyResumeTurnPrompt(issue.Title, request.Message, clarifyAssistantRounds(request.History))
if len(codeBaselines) > 0 {
turnPrompt += "\n\n本次各仓库代码基准为 " + strings.Join(codeBaselines, ";") + "。请重新确认当前工作目录的代码,不要沿用其他分支的代码结论。"
}
diff --git a/internal/repo/opentest.go b/internal/repo/opentest.go
index 8a50afc5..b80a2d22 100644
--- a/internal/repo/opentest.go
+++ b/internal/repo/opentest.go
@@ -123,7 +123,7 @@ func seedTestDefaults(s *Store) error {
}
return s.PutProject(domain.Project{
ID: "platform", Key: "AFP", Name: "AgentFlow Platform", Description: "Agent 原生研发与协作平台", Color: "#3867f4",
- WorkflowID: "requirement-development-production", Clarification: domain.DefaultClarificationPolicy(),
+ WorkflowID: "requirement-development-production",
TAPDWorkspaceID: "10000000", TAPDIterationID: "1000000000000000000",
OwnerID: 1, Members: []domain.ProjectMember{{UserID: 1, Role: "maintainer"}}, CreatedAt: now, UpdatedAt: now,
})
diff --git a/internal/repo/projects.go b/internal/repo/projects.go
index f794b47c..9aa3575d 100644
--- a/internal/repo/projects.go
+++ b/internal/repo/projects.go
@@ -149,9 +149,6 @@ func (r *ProjectsRepo) SetProjectArchived(id string, at *time.Time, by int64) er
func (r *ProjectsRepo) PutProject(v domain.Project) error {
now := time.Now().UTC()
- if v.Clarification.Threshold <= 0 {
- v.Clarification = domain.DefaultClarificationPolicy()
- }
if old, ok := r.Project(v.ID); ok {
if v.OwnerID == 0 {
v.OwnerID = old.OwnerID
diff --git a/internal/schedule/service.go b/internal/schedule/service.go
index b1f0da72..307731b6 100644
--- a/internal/schedule/service.go
+++ b/internal/schedule/service.go
@@ -281,9 +281,6 @@ func (s *Service) execute(job domain.ScheduleJob, triggerOrigin string) (domain.
if s.repo.IssueHasTask(issue.ID) || issue.DeliveryLocked() || issue.GongfengClosed() || issue.Status == "done" || issue.Status == "closed" || issue.Status == "cancelled" || issue.AutomationState == "ignored" {
continue
}
- if project, ok := s.repo.Project(issue.ProjectID); ok && domain.RequirementSOPBlocked(issue, project.Clarification) {
- continue
- }
eligible = append(eligible, issue)
}
blocked := map[string]domain.ScheduleJobBlocker{}
diff --git a/internal/schedule/service_test.go b/internal/schedule/service_test.go
index 5d03b64f..7a475569 100644
--- a/internal/schedule/service_test.go
+++ b/internal/schedule/service_test.go
@@ -459,16 +459,16 @@ func TestRunJobHonorsSourceFilter(t *testing.T) {
}
}
-func TestRunJobSkipsUnmetRequirementClarification(t *testing.T) {
+func TestRunJobDispatchesRequirementsWithoutClarificationGate(t *testing.T) {
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(st.Close)
for _, issue := range []domain.Issue{
- {ID: "thin-req", ProjectID: "platform", Kind: "requirement", Source: "tapd", Status: "todo", WorkflowID: "wf", Clarification: domain.ClarificationAssessment{Score: 20, Status: domain.ClarificationNeedsUser, Gated: true}},
- {ID: "sync-req", ProjectID: "platform", Kind: "requirement", Source: "tapd", Status: "todo", WorkflowID: "wf", Clarification: domain.ClarificationAssessment{Score: 0, Status: domain.ClarificationNeedsUser}},
- {ID: "ready-req", ProjectID: "platform", Kind: "requirement", Source: "tapd", Status: "todo", WorkflowID: "wf", Clarification: domain.ClarificationAssessment{Passed: true, Score: 90, Gated: true}},
+ {ID: "thin-req", ProjectID: "platform", Kind: "requirement", Source: "tapd", Status: "todo", WorkflowID: "wf", Clarification: domain.ClarificationAssessment{Status: domain.ClarificationNeedsUser, Gated: true}},
+ {ID: "sync-req", ProjectID: "platform", Kind: "requirement", Source: "tapd", Status: "todo", WorkflowID: "wf", Clarification: domain.ClarificationAssessment{Status: domain.ClarificationNeedsUser}},
+ {ID: "ready-req", ProjectID: "platform", Kind: "requirement", Source: "tapd", Status: "todo", WorkflowID: "wf", Clarification: domain.ClarificationAssessment{Status: domain.ClarificationReady, Gated: true}},
{ID: "bug", ProjectID: "platform", Kind: "issue", Source: "gongfeng", Status: "todo", WorkflowID: "wf"},
} {
if err := st.PutIssue(issue); err != nil {
@@ -488,14 +488,14 @@ func TestRunJobSkipsUnmetRequirementClarification(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- if result.LastStatus != "success" || result.LastDispatched != 3 {
+ if result.LastStatus != "success" || result.LastDispatched != 4 {
t.Fatalf("result=%+v dispatched=%v", result, dispatched)
}
seen := map[string]bool{}
for _, id := range dispatched {
seen[id] = true
}
- if seen["thin-req"] || !seen["sync-req"] || !seen["ready-req"] || !seen["bug"] {
+ if !seen["thin-req"] || !seen["sync-req"] || !seen["ready-req"] || !seen["bug"] {
t.Fatalf("dispatched=%v", dispatched)
}
}
diff --git a/internal/tracker/service.go b/internal/tracker/service.go
index ea44d26c..89a4eaf2 100644
--- a/internal/tracker/service.go
+++ b/internal/tracker/service.go
@@ -38,7 +38,6 @@ type Service struct {
mrStopCh chan struct{}
deliveryReconcileOnce sync.Once
projectAuth ProjectAuthStore
- OnRequirementImported func(issue domain.Issue)
}
type syncConfigHolder struct {
@@ -1199,9 +1198,6 @@ func (s *Service) upsertTAPDRecord(store IssueStoreAdapter, projectID, workspace
issue.CreatedAt = parseTime(st.Created)
issue.AssigneeUserID = s.resolveTAPDAssignee(store, projectID, assignee, fallbackUserID)
}
- if gateClarification {
- scoreStoredRequirement(store, &issue)
- }
issue.UpdatedAt = time.Now().UTC()
if err := store.PutSyncedIssue(issue); err != nil {
return domain.Issue{}, err
@@ -1287,27 +1283,6 @@ func (s *Service) resolveTAPDAssignee(store IssueStoreAdapter, projectID, owner
return 0
}
-func (s *Service) notifyRequirementImported(issue domain.Issue) {
- if s == nil || s.OnRequirementImported == nil {
- return
- }
- if !domain.ShouldAutoStartClarification(issue) {
- return
- }
- s.OnRequirementImported(issue)
-}
-
-func scoreStoredRequirement(store IssueStoreAdapter, issue *domain.Issue) {
- if issue == nil || !strings.EqualFold(issue.Kind, "requirement") {
- return
- }
- policy := domain.DefaultClarificationPolicy()
- if p, ok := store.Project(issue.ProjectID); ok {
- policy = domain.EffectiveClarificationPolicy(p.Clarification)
- }
- issue.Clarification = domain.ScoreRequirementIssue(*issue, policy)
-}
-
func tapdWorkspaceFromURL(raw string) string {
ref, err := ParseTAPDStoryURL(raw)
if err != nil {
@@ -1366,10 +1341,6 @@ func (s *Service) CreateTAPDStory(store IssueStoreAdapter, issue domain.Issue) (
}
}
- existed := false
- if id := strings.TrimSpace(issue.ID); id != "" {
- _, existed = store.Issue(id)
- }
if issue.Kind == "" {
issue.Kind = "requirement"
}
@@ -1391,14 +1362,7 @@ func (s *Service) CreateTAPDStory(store IssueStoreAdapter, issue domain.Issue) (
_ = store.DeleteIssue(oldID)
}
}
- // Intake scoring belongs to brand-new TAPD stories (import / 新建并同步).
- // Pushing an existing platform ticket must keep its description and
- // clarification; 直接创建 explicitly skipped analysis.
- if !existed {
- scoreStoredRequirement(store, &issue)
- }
_ = store.PutIssue(issue)
- s.notifyRequirementImported(issue)
s.addLog(domain.SyncLog{
ID: fmt.Sprintf("sync-%d", started.UnixNano()), Direction: "push", Source: "tapd",
@@ -2079,7 +2043,7 @@ func mergeIssueKeep(keeper, extra domain.Issue) domain.Issue {
if keeper.RepositoryID == "" {
keeper.RepositoryID = extra.RepositoryID
}
- if keeper.Clarification.Score == 0 && extra.Clarification.Score > 0 {
+ if clarificationEmpty(keeper.Clarification) && !clarificationEmpty(extra.Clarification) {
keeper.Clarification = extra.Clarification
}
if deliveryFieldsPresent(extra) {
@@ -2102,3 +2066,7 @@ func copyDeliveryFields(dst, src domain.Issue) domain.Issue {
dst.DeliveryUpdatedAt = src.DeliveryUpdatedAt
return dst
}
+
+func clarificationEmpty(a domain.ClarificationAssessment) bool {
+ return a.Status == "" && strings.TrimSpace(a.Summary) == "" && len(a.History) == 0
+}
diff --git a/internal/tracker/tapd_import_test.go b/internal/tracker/tapd_import_test.go
index bf32c55c..788817f7 100644
--- a/internal/tracker/tapd_import_test.go
+++ b/internal/tracker/tapd_import_test.go
@@ -29,11 +29,8 @@ func TestImportTAPDStoryFromDetailURL(t *testing.T) {
if issue.Title != "国际站取回绑定套餐域名逻辑对齐国内站" {
t.Fatalf("title=%q", issue.Title)
}
- if issue.Clarification.Passed || issue.Clarification.Status != domain.ClarificationNeedsUser || !issue.Clarification.Gated {
- t.Fatalf("thin import must need clarification: %+v", issue.Clarification)
- }
- if len(issue.Clarification.Dimensions) == 0 {
- t.Fatal("import score must not return empty dimensions")
+ if issue.Clarification.Status != "" || issue.Clarification.Gated {
+ t.Fatalf("import must not score or gate clarification: %+v", issue.Clarification)
}
if issue.ExternalRef == nil || issue.ExternalRef.ExternalID != "1010000000100000555" {
t.Fatalf("external=%+v", issue.ExternalRef)
@@ -226,25 +223,6 @@ func TestImportTAPDStoryKeepsExistingAssignee(t *testing.T) {
}
}
-func TestImportTAPDStoryScoresCompleteDescription(t *testing.T) {
- payload := `{"data":[{"id":"1002","name":"国际站绑定对齐","status":"open","description":"<p>目标是解决国际站绑定套餐域名和国内站不一致的问题,预期产生对齐全站业务价值。</p><p>用户是国际站套餐管理员,在续费场景下使用。</p><p>本次范围包含取回绑定逻辑,不包含计费边界。</p><p>验收标准:国内站与国际站绑定结果一致,相关接口测试通过即可判断完成。</p><p>约束是必须兼容现有套餐依赖,本迭代截止前交付,注意回滚风险。</p>"}]}`
- gateway := mockTAPDStoriesGateway(t, payload)
- defer gateway.Close()
- svc := NewService()
- svc.Configure(domain.SyncConfig{TAPDMCPURL: gateway.URL})
- store := &memIssueStore{projects: map[string]domain.Project{"dp": {ID: "dp", Name: "DemoDNS"}}}
- issue, err := svc.ImportTAPDStory(store, "dp", "https://tapd.example.com/tapd_fe/10000000/story/detail/1002", 0)
- if err != nil {
- t.Fatal(err)
- }
- if !issue.Clarification.Passed || issue.Clarification.Score < 80 {
- t.Fatalf("complete description should pass: %+v", issue.Clarification)
- }
- if issue.Clarification.Status == domain.ClarificationNeedsUser {
- t.Fatal("passed import must not ask the user to clarify")
- }
-}
-
func TestSyncTAPDStoryDoesNotScoreOrGate(t *testing.T) {
gateway := mockTAPDStoriesGateway(t, `{"data":[{"id":"3001","name":"【国内站】mq_flush_dns命令CMQ SDK连接异常","status":"open"}]}`)
defer gateway.Close()
@@ -255,7 +233,7 @@ func TestSyncTAPDStoryDoesNotScoreOrGate(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- if issue.Clarification.Gated || issue.Clarification.Score != 0 || len(issue.Clarification.Dimensions) != 0 {
+ if issue.Clarification.Gated || issue.Clarification.Status != "" {
t.Fatalf("sync must not score: %+v", issue.Clarification)
}
}
diff --git a/web/app/composer.js b/web/app/composer.js
index 653bd696..9091d5a3 100644
--- a/web/app/composer.js
+++ b/web/app/composer.js
@@ -20,30 +20,7 @@ function reqCreateAccepted(){
return !state.reqClarifySkipped&&!!state.chatClarifyResult?.ready;
}
function composerClarifyQuestions(aiResult){
- const questions=normalizeClarifyParsed(aiResult).questions;
- if(questions.length||!aiResult||aiResult.ready)return questions;
- // Older responses may only contain missing information. Preserve it as
- // free-text questions; business choices must come from the analyst.
- return composerAssessmentView(aiResult).missingNames.map((question,i)=>({id:`missing${i+1}`,question:String(question),options:[],freeText:true}));
-}
-function composerAssessmentView(aiResult){
- const policy=clarificationPolicy(currentProject());
- const dims=policy.dimensions||[];
- const rating=aiResult?.assessment||{};
- const ratings=rating.dimensions&&typeof rating.dimensions==='object'?rating.dimensions:{};
- const missing=Array.isArray(rating.missing)?rating.missing:[];
- const missingNames=missing.map(m=>{
- const dim=dims.find(d=>d.id===m);
- return dim?dim.name:m;
- }).filter(Boolean);
- let weighted=0,weight=0;
- dims.forEach(d=>{
- if(ratings[d.id]===undefined)return;
- const w=Number(d.weight)||0;
- weighted+=(Number(ratings[d.id])||0)*w;
- weight+=w;
- });
- return {dims,ratings,missing,missingNames,score:weight?Math.round(weighted/weight):0,threshold:policy.threshold||80,ready:!!aiResult?.ready};
+ return normalizeClarifyParsed(aiResult).questions;
}
function reqAnswerOf(index){
const answer=(state.reqAnswers||{})[index];
@@ -56,7 +33,7 @@ function reqQuestionAnswered(index){
function reqAnsweredCount(questions){
return questions.filter((_,i)=>reqQuestionAnswered(i)).length;
}
-// composerProgressHTML 只给出「还有 N 个问题 / 已问清」,评分收进 composerAssessmentDetailsHTML 的折叠区。
+// composerProgressHTML 只给出「还有 N 个问题 / 已问清」。
function composerProgressHTML(aiResult){
if(!aiResult)return '';
if(aiResult.ready)return '<span class="hui-badge" data-tone="success"><span class="hui-lamp is-still"><i></i></span>已问清,可以创建</span>';
@@ -65,18 +42,6 @@ function composerProgressHTML(aiResult){
const label=!questions.length?'还需要补充说明':(remaining?`还有 ${remaining} 个问题`:'已答完,提交后继续分析');
return `<span class="hui-badge" data-tone="warn"><span class="hui-lamp is-still"><i></i></span>${label}</span>`;
}
-function composerAssessmentDetailsHTML(aiResult){
- const view=composerAssessmentView(aiResult);
- const ids=Object.keys(view.ratings);
- if(!ids.length)return '';
- const rows=ids.map(id=>{
- const dim=view.dims.find(d=>d.id===id);
- const value=Math.max(0,Math.min(100,Math.round(Number(view.ratings[id])||0)));
- return `<div class="req-dim"><span>${escapeHTML(dim?.name||id)}</span><span class="req-meter"><i style="width:${value}%"></i></span><b>${value}</b></div>`;
- }).join('');
- const missing=view.missingNames.length?`<div class="req-dim-missing">缺失项:${view.missingNames.map(n=>escapeHTML(n)).join('、')}</div>`:'';
- return `<details class="req-score-details"><summary class="req-fold">${reqIcon('chevron-down')}查看完整度详情</summary><div class="req-score-body">${rows}<div class="req-dim req-dim-total"><span>综合</span><span class="req-dim-line">项目准入线 ${view.threshold}</span><b>${view.score}</b></div>${missing}</div></details>`;
-}
function projectTAPDReady(project){
project=project||currentProject();
if(!project)return false;
@@ -307,7 +272,7 @@ function renderClarifyPanel(aiResult, err){
let html=clarifyRepoNoticeHTML(aiResult.repository);
html+=`<div class="req-cl-top">${composerProgressHTML(aiResult)}<span class="req-toolbar-sp"></span>${recommend}</div>`;
if(aiResult.ready){
- html+=`<div class="req-ready-card"><div class="req-ready-head">${reqIcon('check',16)}需求结论</div><div class="req-ready-body">${escapeHTML(summary||'信息已经够用,可以创建。')}</div>${composerAssessmentDetailsHTML(aiResult)}</div>`;
+ html+=`<div class="req-ready-card"><div class="req-ready-head">${reqIcon('check',16)}需求结论</div><div class="req-ready-body">${escapeHTML(summary||'信息已经够用,可以创建。')}</div></div>`;
html+=reqSupplementHTML('还有要补充的?写在这里会再分析一次','例如:徽章需要支持点击查看获得方式','补充并重新分析');
}else{
if(summary)html+=`<p class="req-understand"><b>分析师的理解</b>${escapeHTML(summary)}</p>`;
@@ -315,8 +280,6 @@ function renderClarifyPanel(aiResult, err){
html+=`<div class="req-clarify-note"><span>分析师没有给出具体问题,可以补充说明,也可以重新生成问题。</span><button type="button" class="button small" id="chatClarifyRetry">${reqIcon('refresh')}重新生成问题</button></div>`;
}
html+=questions.length?reqQuestionCardHTML(questions):reqSupplementHTML('补充说明','补充背景、范围或验收标准','提交补充');
- const details=composerAssessmentDetailsHTML(aiResult);
- if(details)html+=`<div class="req-score-wrap">${details}</div>`;
}
panel.hidden=false;
panel.innerHTML=html;
@@ -1133,14 +1096,13 @@ async function createIssueFromChat(target){
clarification:state.reqClarifyStartedAt?{startedAt:state.reqClarifyStartedAt}:undefined
};
}else{
- const rating=r.assessment||{};
const summary=usableClarifySummary(r.summary);
payload={
...base,
title:title||r.suggestedTitle||chatHistory[0]?.content?.slice(0,80)||'新工作项',
description:summary||chatHistory.filter(h=>h.role==='user').map(h=>h.content).join('\n\n'),
priority:r.suggestedPriority||'medium',
- clarification:{summary:summary||'',dimensions:rating.dimensions,missing:rating.missing||[],questions:r.questions||[],status:accepted?'ready':'in_progress',passed:accepted,gated:accepted,startedAt:state.reqClarifyStartedAt||undefined}
+ clarification:{summary:summary||'',questions:r.questions||[],status:accepted?'ready':'in_progress',startedAt:state.reqClarifyStartedAt||undefined}
};
}
let issue=await api('/api/issues',{method:'POST',body:JSON.stringify(payload)});
@@ -1161,13 +1123,12 @@ async function createIssueFromChat(target){
$('#requirementModal').classList.remove('open');
renderIssues();
if(direct){
- toast(target==='tapd'?`已创建需求并同步 TAPD ${issue.externalRef?.externalId||''}`:'已在平台创建需求。未经澄清,不会立刻启动 SOP','ok');
+ toast(target==='tapd'?`已创建需求并同步 TAPD ${issue.externalRef?.externalId||''}`:'已在平台创建需求,可在详情里触发 SOP','ok');
openIssueDetail(issue.id);
return;
}
- if(!accepted||requirementNeedsClarification(issue)){
- state.autoStartClarify=!issue.clarification?.questions?.length;
- toast(target==='tapd'?'已在 TAPD 创建需求。澄清尚未完成,请在澄清页继续,完成后再触发 SOP':'已在平台创建需求。澄清尚未完成,请在澄清页继续,完成后再触发 SOP','ok');
+ if(!accepted){
+ toast(target==='tapd'?'已在 TAPD 创建需求。澄清尚未完成,可在澄清页继续,也可以直接触发 SOP':'已在平台创建需求。澄清尚未完成,可在澄清页继续,也可以直接触发 SOP','ok');
openIssueDetail(issue.id,'clarify');
return;
}
diff --git a/web/app/issue-drawer.js b/web/app/issue-drawer.js
index de4f6b22..a4b1766f 100644
--- a/web/app/issue-drawer.js
+++ b/web/app/issue-drawer.js
@@ -42,42 +42,29 @@ async function openIssueDetail(id,tab){
}
}
state.issueDetailData={issue,comments,run,task,requirement};
- const health=issueRunHealth(issue),stage=issueCurrentStage(issue),needsClarify=requirementNeedsClarification(issue),needsConfirm=clarificationNeedsConfirm(issue);
- state.issueDetailTab=tab||(issueClarifying(issueId)||needsClarify||needsConfirm?'clarify':((health==='attention'||health==='active'||stage.key==='waiting')?'sop':'overview'));
+ const health=issueRunHealth(issue),stage=issueCurrentStage(issue),needsConfirm=clarificationNeedsConfirm(issue);
+ state.issueDetailTab=tab||(issueClarifying(issueId)||needsConfirm?'clarify':((health==='attention'||health==='active'||stage.key==='waiting')?'sop':'overview'));
$$('#issueDetailTabs .drawer-tab').forEach(b=>b.classList.toggle('active',b.dataset.dtab===state.issueDetailTab));
renderIssueDetailTab();
if(issueClarifying(issueId)){
restoreIssueClarifyThinking(issueId);
attachIssueClarifyStream(issueId);
}
- if(state.autoStartClarify&&(needsClarify||issueClarifying(issueId))){
- state.autoStartClarify=false;
- if(!issueClarifying(issueId))openIssueClarification(true);
- else{setIssueClarifyTab();renderIssueDetailTab();attachIssueClarifyStream(issueId)}
- }else{state.autoStartClarify=false}
- }catch(e){state.autoStartClarify=false;$('#issueDetailBody').innerHTML=`<div class="detail-empty">加载失败:${escapeHTML(e.message)}</div>`}
+ }catch(e){$('#issueDetailBody').innerHTML=`<div class="detail-empty">加载失败:${escapeHTML(e.message)}</div>`}
}
function issueClarifyViewKey(issue,project){
const c=issue?.clarification||{};
- const policy=clarificationPolicy(project);
return JSON.stringify({
analyzing:!!issueClarifying(issue?.id),
status:c.status||'',
- score:c.score||0,
- passed:!!c.passed,
- gated:!!c.gated,
lastError:c.lastError||'',
summary:c.summary||'',
writeBack:c.writeBackStatus||'',
writeBackError:c.writeBackError||'',
questions:(c.questions||[]).map(q=>({question:q.question||'',multi:!!q.multiSelect,options:clarifyQuestionOptions(q)})),
- missing:c.missing||[],
- dimensions:c.dimensions||{},
history:(c.history||[]).map(h=>({role:h.role||'',content:h.content||''})),
- threshold:policy?.threshold||0,
source:issue?.source||'',
external:issue?.externalRef?.externalUrl||'',
- needs:!!requirementNeedsClarification(issue),
confirm:!!clarificationNeedsConfirm(issue),
blocked:issueExecutionBlocked(issue)||''
});
@@ -231,23 +218,18 @@ function renderIssueDetailTab(){
function drawerFact(label,value,title){return `<div class="detail-fact"><span>${label}</span><b title="${escapeHTML(title||value||'')}">${value===''||value==null?'—':value}</b></div>`}
function clarificationOverviewCard(issue){
const c=issue.clarification||{},source=issue.source==='gongfeng'?'工蜂':issue.source==='tapd'?'TAPD':'LoopForge';
- const score=c.score||0;
if(issueClarifying(issue.id)||c.status==='analyzing'){
return `<div class="clarify-overview"><span>…</span><div><b>澄清正在后台分析</b><small>关闭网页也不会中断,点查看可回到分析过程</small></div><button class="button ghost small" data-start-clarify>查看</button></div>`;
}
- if(requirementNeedsClarification(issue)&&c.status!=='in_progress'&&c.status!=='ready'){
- return `<div class="clarify-overview needs-user"><span>!</span><div><b>导入评分 ${score} 分,需要你处理</b><small>未达项目准入线,点这里开始澄清后再触发 SOP</small></div><button class="button primary small" data-start-clarify>去澄清</button></div>`;
- }
if(c.status==='ready'&&c.summary){
const failed=c.writeBackStatus==='failed';
const pending=c.writeBackStatus==='pending';
- const scoreLabel=score?` · ${score} 分`:'';
const cls=failed||pending?'failed':'ready';
- const title=failed?`澄清已完成${scoreLabel},写回失败`:pending?`澄清已完成${scoreLabel},待确认写回`:`已澄清${scoreLabel} · ${c.writeBackStatus==='succeeded'?`已写回 ${source}`:'结论已保存'}`;
+ const title=failed?'澄清已完成,写回失败':pending?'澄清已完成,待确认写回':`已澄清 · ${c.writeBackStatus==='succeeded'?`已写回 ${source}`:'结论已保存'}`;
return `<div class="clarify-overview ${cls}"><span>${failed||pending?'!':'✓'}</span><div><b>${title}</b><small>${escapeHTML((c.summary||'').slice(0,120))}${c.summary&&c.summary.length>120?'…':''}</small></div><button class="button ghost small" data-start-clarify>查看</button></div>`;
}
if(c.status==='in_progress'){
- return `<div class="clarify-overview"><span>…</span><div><b>澄清尚未完成</b><small>继续回答关键问题,进度已经保存</small></div><button class="button ghost small" data-start-clarify>继续</button></div>`;
+ return `<div class="clarify-overview"><span>…</span><div><b>澄清尚未完成</b><small>继续回答关键问题,进度已经保存;不影响直接触发 SOP</small></div><button class="button ghost small" data-start-clarify>继续</button></div>`;
}
return `<div class="clarify-overview"><span>?</span><div><b>描述不够清楚?</b><small>结合原单和代码问清关键细节</small></div><button class="button ghost small" data-start-clarify>帮我问清楚</button></div>`;
}
@@ -550,34 +532,6 @@ function overviewPane(issue,data){
const facts=`<div class="detail-grid">${drawerFact('责任人',issueAssigneeName(issue)||'未指定')}${drawerFact('优先级',issuePriorityLabel(issue.priority))}${drawerFact('来源',issueSourceLabel(issue))}${metricsIssueSource(issue)==='local'?drawerFact('统计关联 TAPD',escapeHTML(issue.tapdId||'未绑定(仍参与统计)')):''}${drawerFact('触发方式',convo?'对话工作区':escapeHTML(taskTriggerInfo(data.task).label))}${drawerFact('关联 SOP',convo?'无 · 对话里直接改代码':escapeHTML(workflow?.name||'未关联'))}${drawerFact('代码仓库',escapeHTML(repo?.name||'未绑定'))}${convo?drawerFact('工作分支',escapeHTML(conversationWorkBranchNames(issue,data)||'—')):drawerFact('继续开发分支',escapeHTML(storedIssueWorkBranch(issue)||'自动新建'))}</div>`;
return `<div class="detail-section">${banner}${facts}${issue.description?`<div class="detail-desc" style="margin-top:12px">${escapeHTML(issue.description)}</div>`:''}${clarificationOverviewCard(issue)}</div>`;
}
-// Bug-style items are rated on reproduction quality; requirements use the
-// project's configurable policy. Mirrors clarificationRatingDimensions in Go.
-function issueClarifyDimensions(issue,project){
- if(issue.source==='gongfeng'||issue.kind==='issue')return[
- {id:'phenomenon',name:'现象与复现'},{id:'impact',name:'影响范围'},{id:'expected',name:'期望行为'},
- {id:'acceptance',name:'验收标准'},{id:'constraints',name:'约束与依赖'}];
- return clarificationPolicy(project).dimensions||[];
-}
-function clarifyScoreLevel(score){return score>=80?'good':score>=60?'fair':'weak'}
-function clarifyScoreHTML(issue,project){
- const c=issue.clarification||{},ratings=c.dimensions||{};
- if(!Object.keys(ratings).length)return'';
- const dims=issueClarifyDimensions(issue,project),threshold=clarificationPolicy(project).threshold||0;
- const bars=dims.filter(d=>ratings[d.id]!==undefined).map(d=>{
- const v=ratings[d.id]||0;
- return `<div class="clarify-rate"><span>${escapeHTML(d.name||d.id)}</span><i><b class="${clarifyScoreLevel(v)}" style="width:${v}%"></b></i><em>${v}</em></div>`;
- }).join('');
- const missingNames=(c.missing||[]).map(m=>{
- const dim=dims.find(d=>d.id===m);
- return dim?dim.name:m;
- });
- const missing=missingNames.map(name=>`<span class="clarify-missing-chip"><i></i>${escapeHTML(name)}</span>`).join('');
- const missingBlock=missing?`<div class="clarify-missing"><div class="clarify-missing-head"><svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 9v4"/><path d="M12 17h.01"/><path d="M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0Z"/></svg><b>仍未确认 · ${missingNames.length} 项</b></div><div class="clarify-missing-list">${missing}</div></div>`:'';
- return `<div class="clarify-score">
- <div class="clarify-score-total ${clarifyScoreLevel(c.score||0)}"><b>${c.score||0}</b><span>信息完整度</span></div>
- <div class="clarify-score-body">${bars}${threshold?`<small>${c.status==='ready'||c.passed?`信息完整度 ${c.score||0} 分,澄清完成后可触发 SOP。`:`项目准入线 ${threshold} 分;未达标需先完成澄清。`}</small>`:''}</div>
- </div>${missingBlock}`;
-}
function clarifyHistoryHTML(c){
const rows=[];
(c.history||[]).forEach(msg=>{
@@ -603,16 +557,16 @@ function clarifyPane(issue,project){
const retry=c.writeBackStatus==='failed'?`<button class="button primary small" data-retry-clarify>重试写回原单</button>`:'';
const confirm=pending?`<button class="button primary small" data-retry-clarify title="确认写回原单(追加评论)之后,即可开始触发需求">确认写回原单(追加评论)</button>`:'';
const external=issue.externalRef?.externalUrl?`<a class="button ghost small" href="${escapeHTML(safeURL(issue.externalRef.externalUrl))}" target="_blank" rel="noopener noreferrer">打开原单 ↗</a>`:'';
- const trigger=!pending&&!issueExecutionBlocked(issue)?`<button class="button primary small" data-dispatch-issue="${escapeHTML(issue.id)}" title="需求已具备进入研发准入条件,点击直接触发 SOP">触发需求</button>`:'';
+ const trigger=!pending&&!issueExecutionBlocked(issue)?`<button class="button primary small" data-dispatch-issue="${escapeHTML(issue.id)}" title="按澄清结论触发 SOP">触发需求</button>`:'';
const blockedHint=!pending&&issueExecutionBlocked(issue)?(issueTrackerClosed(issue)&&!issueManuallyClosed(issue)?closedTrackerHint(issue):deliveredHint(issue)):'';
const stepGuide=pending?`<div class="clarify-next-step-callout"><div class="clarify-step-badge active"><span class="step-num">1</span><span>确认写回原单(追加评论)</span></div><span class="clarify-step-arrow">➔</span><div class="clarify-step-badge"><span class="step-num">2</span><span>触发需求执行 SOP</span></div></div>`:'';
const head=pending
?`<div class="clarify-ready-head"><span class="clarify-check warn">!</span><div><b>请确认澄清结论并写回原单</b><small>结论已追加到平台说明。确认写回原单(追加评论)后,即可开始触发需求执行 SOP(不会修改原单描述)</small></div></div>${stepGuide}`
- :`<div class="clarify-ready-head"><span class="clarify-check">✓</span><div><b>澄清已完成${c.writeBackStatus==='succeeded'?` · 已写回 ${source} 评论`:''}</b><small class="${c.writeBackStatus==='failed'?'danger':''}">${escapeHTML(writeBack||'结论已保存到平台说明')},已满足准入条件,可直接触发需求执行 SOP</small></div></div>`;
+ :`<div class="clarify-ready-head"><span class="clarify-check">✓</span><div><b>澄清已完成${c.writeBackStatus==='succeeded'?` · 已写回 ${source} 评论`:''}</b><small class="${c.writeBackStatus==='failed'?'danger':''}">${escapeHTML(writeBack||'结论已保存到平台说明')},可直接触发需求执行 SOP</small></div></div>`;
const actionTip=pending
?`<div class="clarify-action-hint">确认写回原单(追加评论)后,即可开始触发需求</div>`
- :(trigger?`<div class="clarify-action-hint ok">已写回原单并满足准入条件,可直接点击「触发需求」开始执行</div>`:'');
- return `<div class="clarify-workspace">${head}${clarifyVisibleSummary(c.summary)?`<div class="clarify-summary">${escapeHTML(clarifyVisibleSummary(c.summary))}</div>`:''}${clarifyScoreHTML(issue,project)}${c.writeBackError?`<div class="clarify-error">${escapeHTML(c.writeBackError)}</div>`:''}${clarifyHistoryHTML(c)}<div class="clarify-actions">${confirm}${trigger}${blockedHint}${retry}${external}<button class="button ghost small" data-reclarify>再问一轮</button>${actionTip}</div></div>`;
+ :(trigger?`<div class="clarify-action-hint ok">可直接点击「触发需求」开始执行</div>`:'');
+ return `<div class="clarify-workspace">${head}${clarifyVisibleSummary(c.summary)?`<div class="clarify-summary">${escapeHTML(clarifyVisibleSummary(c.summary))}</div>`:''}${c.writeBackError?`<div class="clarify-error">${escapeHTML(c.writeBackError)}</div>`:''}${clarifyHistoryHTML(c)}<div class="clarify-actions">${confirm}${trigger}${blockedHint}${retry}${external}<button class="button ghost small" data-reclarify>再问一轮</button>${actionTip}</div></div>`;
}
const questions=c.questions||[];
const analyzing=issueClarifying(issue.id);
@@ -620,22 +574,16 @@ function clarifyPane(issue,project){
const questionHTML=analyzing?'':clarifyQuestionCardsHTML(questions,saved);
const submittedHTML=analyzing?clarifySubmittedHTML(saved?.reply):'';
if(c.status!=='in_progress'&&!analyzing){
- const scored=c.score||Object.keys(c.dimensions||{}).length;
- const need=requirementNeedsClarification(issue);
- const intro=need
- ?`<div class="clarify-orb">!</div><h3>导入评分 ${c.score||0} 分,需要你补充</h3><p>未达项目准入线。分析师会结合这张单和本项目代码提出关键问题,补齐后再触发 SOP。</p>`
- :`<div class="clarify-orb">?</div><h3>描述不够清楚?一起问明白</h3><p>分析师会结合这张单和本项目代码提出关键问题。确认信息够用后,这里会出现「澄清已完成」,才能触发需求。</p>`;
- const legacy=scored&&!need?`<div class="clarify-summary compact">已有结构化澄清:${c.score||0}/100 · ${c.passed?'已通过':'未通过'}。</div>`:'';
- return `<div class="clarify-workspace clarify-empty">${legacy}${intro}${need?clarifyScoreHTML(issue,project):''}<div class="clarify-start-row">${clarifyModelPickerHTML(false)}<button class="button primary" data-start-clarify>${need?'开始澄清':'开始澄清'}</button></div></div>`;
+ const intro=`<div class="clarify-orb">?</div><h3>描述不够清楚?一起问明白</h3><p>可选步骤。分析师只围绕这张单本身,结合本项目代码问清阻塞开工的细节;不澄清也可以直接触发 SOP。</p>`;
+ return `<div class="clarify-workspace clarify-empty">${intro}<div class="clarify-start-row">${clarifyModelPickerHTML(false)}<button class="button primary" data-start-clarify>开始澄清</button></div></div>`;
}
const lastError=(!analyzing&&c.lastError)?`<div class="clarify-error req-clarify-retry"><span>${escapeHTML(c.lastError)}</span><button type="button" class="button primary small" data-retry-clarify-turn>重新分析</button></div>`:'';
const rounds=(c.history||[]).filter(m=>m.role==='assistant').length;
- const lastParsed=latestClarifyParsed(c);
- const progressIssue={...issue,clarification:{...c,...((!c.score&&lastParsed?.assessment)?{dimensions:lastParsed.assessment.dimensions||{},missing:lastParsed.assessment.missing||[]}:{})}};
- const scoreBlock=clarifyScoreHTML(progressIssue,project);
- const nextHint=analyzing?'正在后台分析,关闭详情不会中断':(c.lastError?'上次分析未完成,可重新分析':`回答后点「继续澄清」。分析师确认够用后会出现「澄清已完成」,才能触发需求。已澄清 ${rounds||0} 轮。`);
+ // Own text node so the sentence matches an English entry; a trailing count does not.
+ const roundNote=(!analyzing&&!c.lastError)?`已澄清 ${rounds||0} 轮。`:'';
+ const nextHint=analyzing?'正在后台分析,关闭详情不会中断':(c.lastError?'上次分析未完成,可重新分析':'回答后点「继续澄清」。分析师确认够用后会给出结论;也可以随时直接触发 SOP。');
const composerInput=analyzing?'':`<textarea id="issueClarifyInput" rows="3" placeholder="${questions.length?'点选上面的答案,或补充说明':'补充你认为重要的信息'}">${escapeHTML(saved?.extra||'')}</textarea>`;
- return `<div class="clarify-workspace"><div class="clarify-intro"><span>AI</span><div><b>${analyzing?'正在分析这张':'继续完善这张'}${issue.source==='gongfeng'?' Issue':'需求'}</b><small>${analyzing?'关闭详情不会中断,再打开可继续看过程':'每轮只问最关键的 1–3 个问题;确认够用前不会出现「触发需求」'}</small></div>${clarifyModelPickerHTML(analyzing)}</div>${clarifyVisibleSummary(c.summary)?`<div class="clarify-summary compact">${escapeHTML(clarifyVisibleSummary(c.summary))}</div>`:''}${scoreBlock}${clarifyHistoryHTML(c)}${submittedHTML}${questionHTML}${lastError}<div id="issueClarifyThinking" class="req-thinking-stream" hidden></div><div class="issue-clarify-composer">${composerInput}<div><span id="issueClarifyHint">${nextHint}</span><span><button class="button ghost small" data-stop-clarify ${analyzing?'':'hidden'}>停止</button> <button class="button primary small" data-continue-clarify${analyzing?' disabled':''}>${analyzing?'分析中…':(c.lastError?'重新分析':'继续澄清')}</button></span></div></div></div>`;
+ return `<div class="clarify-workspace"><div class="clarify-intro"><span>AI</span><div><b>${analyzing?'正在分析这张':'继续完善这张'}${issue.source==='gongfeng'?' Issue':'需求'}</b><small>${analyzing?'关闭详情不会中断,再打开可继续看过程':'每轮只问最关键的 1–3 个问题,只围绕这张单本身'}</small></div>${clarifyModelPickerHTML(analyzing)}</div>${clarifyVisibleSummary(c.summary)?`<div class="clarify-summary compact">${escapeHTML(clarifyVisibleSummary(c.summary))}</div>`:''}${clarifyHistoryHTML(c)}${submittedHTML}${questionHTML}${lastError}<div id="issueClarifyThinking" class="req-thinking-stream" hidden></div><div class="issue-clarify-composer">${composerInput}<div><span id="issueClarifyHint">${nextHint}${roundNote?` <span>${roundNote}</span>`:''}</span><span><button class="button ghost small" data-stop-clarify ${analyzing?'':'hidden'}>停止</button> <button class="button primary small" data-continue-clarify${analyzing?' disabled':''}>${analyzing?'分析中…':(c.lastError?'重新分析':'继续澄清')}</button></span></div></div></div>`;
}
function latestClarifyParsed(c){
const rows=[...(c?.history||[])].reverse();
@@ -643,7 +591,7 @@ function latestClarifyParsed(c){
if(msg.role!=='assistant')continue;
try{
const parsed=JSON.parse(msg.content||'');
- if(parsed&&typeof parsed==='object'&&(parsed.questions||parsed.ready||parsed.assessment))return parsed;
+ if(parsed&&typeof parsed==='object'&&(parsed.questions||parsed.ready))return parsed;
}catch{}
}
return null;
@@ -834,8 +782,8 @@ function sopPane(issue,data){
const nodeRows=stageRows(plannedSOPNodes(lane,wf),0);
const singleSOP=effectiveIssueSOPBindings(issue).length<=1;
const actionWorkflow=singleSOP&&String(issue.workflowId||'').trim()?issue.workflowId:lane.workflowId;
- const canStart=actionWorkflow&&!issueExecutionBlocked(issue)&&!clarificationNeedsConfirm(issue)&&!requirementNeedsClarification(issue)&&!lane.started;
- const canRetriggerLane=actionWorkflow&&lane.started&&!issueManuallyClosed(issue)&&!issueTrackerClosed(issue)&&!clarificationNeedsConfirm(issue)&&!requirementNeedsClarification(issue);
+ const canStart=actionWorkflow&&!issueExecutionBlocked(issue)&&!clarificationNeedsConfirm(issue)&&!lane.started;
+ const canRetriggerLane=actionWorkflow&&lane.started&&!issueManuallyClosed(issue)&&!issueTrackerClosed(issue)&&!clarificationNeedsConfirm(issue);
const trigger=canStart?`<button class="button primary small" data-dispatch-issue="${escapeHTML(issue.id)}" data-workflow="${escapeHTML(actionWorkflow)}">触发</button>`:(canRetriggerLane?`<button class="button ghost small" data-retrigger-issue="${escapeHTML(issue.id)}" data-workflow="${escapeHTML(actionWorkflow)}">重新触发</button>`:'');
const ownerName=userDisplay(userById(lane.assigneeUserId||issue.assigneeUserId))||'需求跟进人';
const hint=lane.started?`${lane.runCount||0} 次 · ${formatTokens(lane.tokens||0)}`:'展开可看节点';
diff --git a/web/app/issue-model.js b/web/app/issue-model.js
index 731cea2d..5f0cd2bd 100644
--- a/web/app/issue-model.js
+++ b/web/app/issue-model.js
@@ -231,7 +231,6 @@ function issueRunHealth(i){
if(run?.status==='failed'||run?.status==='cancelled'||issueHasFailedNode(run))return'attention';
if(issueClarifying(i.id))return'active';
if(clarificationNeedsConfirm(i))return'attention';
- if(requirementNeedsClarification(i))return'attention';
if(task&&['queued','dispatched','running'].includes(task.status))return'active';
if(!task||!run)return'not_started';
return'not_started';
@@ -257,10 +256,6 @@ function issueActor(i){
if(issueClarifying(i.id))return{kind:'active',title:'澄清分析中',sub:'关闭网页也不会中断'};
const task=latestIssueTask(i);
if(task&&['queued','dispatched','running'].includes(task.status))return{kind:'active',title:'正在启动',sub:task.status==='queued'?'排队中':'调度中'};
- if(requirementNeedsClarification(i)){
- const score=i.clarification?.score||0;
- return{kind:'attention',title:'需要你澄清',sub:`${score} 分 · 未达准入线`};
- }
if(issueRunHealth(i)==='attention')return{kind:'attention',title:'需要介入',sub:issueCurrentStage(i).hint||'运行失败或已中断'};
if(bound)return{kind:'bound',title:bound.name,sub:'已绑定 Agent'};
return{kind:'idle',title:'尚未执行',sub:'触发后由 SOP 节点 Agent 接手'};
@@ -274,10 +269,6 @@ function issueOutcome(i){
if(clarificationNeedsConfirm(i)){
return{key:'confirm',short:'待确认',title:'请确认澄清结论并写回原单',body:'结论已追加到平台说明。确认写回原单(追加评论)后,即可开始触发需求执行 SOP。'};
}
- if(requirementNeedsClarification(i)){
- const score=i.clarification?.score||0,threshold=clarificationPolicy((state.data.projects||[]).find(p=>p.id===i.projectId)).threshold||80;
- return{key:'attention',short:'待澄清',title:'需要你补充澄清',body:`导入评分 ${score} 分,未达准入线 ${threshold} 分。请先回答澄清问题后再触发 SOP。`};
- }
if(conversationWorkspaceIssue(i)){const c=conversationIssueStage(i);return{key:c.ended?'idle':c.key==='closed'?'closed':'active',short:c.short,title:`对话交付 · ${c.label}`,body:c.hint};}
if(latestIssueRun(i)?.status==='cancelled')return{key:'attention',short:'已取消',title:'运行已取消',body:'这次运行已结束且工作区已清理,不能接着原记录重试。可以重新触发整条 SOP。'};
if(health==='attention')return{key:'attention',short:'失败',title:'运行失败',body:`停在「${stage.label}」。可从失败节点重试,或整条重新触发。`};
@@ -404,7 +395,7 @@ function deliveredHint(issue){const label=deliveryLockedLabel(issue);return `<sp
function reopenDeliveredButton(issue,{cls='button primary small'}={}){if(issueTrackerClosed(issue)||(!issueManuallyClosed(issue)&&!deliveryLocked(issue)))return'';return `<button type="button" class="${cls}" data-reopen-issue="${escapeHTML(issue.id)}">重新打开</button>`}
function canRetriggerIssue(issue,run){
if(!issue||issueManuallyClosed(issue)||issueTrackerClosed(issue))return false;
- if(clarificationNeedsConfirm(issue)||requirementNeedsClarification(issue))return false;
+ if(clarificationNeedsConfirm(issue))return false;
const current=run||latestIssueRun(issue);
if(current&&['queued','running','waiting'].includes(current.status))return false;
if(deliveryLocked(issue))return true;
@@ -418,7 +409,6 @@ function retriggerButton(issue,run,{ghost=false,cls}={}){
function triggerSOPButton(issue,{ghost=false,cls='button primary small',text='触发'}={}){
if(issueExecutionBlocked(issue))return issueTrackerClosed(issue)&&!issueManuallyClosed(issue)?closedTrackerHint(issue):deliveredHint(issue);
if(clarificationNeedsConfirm(issue))return `<button class="${ghost?'button ghost small':cls}" data-start-clarify title="请先确认澄清结论并写回原单">去确认结论</button>`;
- if(requirementNeedsClarification(issue))return `<button class="${ghost?'button ghost small':cls}" data-start-clarify title="需求未达准入线,请先补充澄清">去澄清</button>`;
return `<button class="${ghost?'button ghost small':cls}" data-dispatch-issue="${escapeHTML(issue.id)}">${text}</button>`;
}
function issueActionButtons(i){
@@ -429,7 +419,6 @@ function issueActionButtons(i){
if(issueManuallyClosed(i)||deliveryLocked(i)||issueTrackerClosed(i))return `${run?`<button type="button" class="issue-act" data-view-run="${escapeHTML(run.id)}">查看</button>`:''}${more}`;
if(issueClarifying(i.id))return `<button type="button" class="issue-act" data-open-issue="${escapeHTML(i.id)}" data-dtab="clarify">查看分析</button>${more}`;
if(clarificationNeedsConfirm(i))return `<button type="button" class="issue-act primary" data-open-issue="${escapeHTML(i.id)}" data-dtab="clarify">确认结论</button>${more}`;
- if(requirementNeedsClarification(i))return `<button type="button" class="issue-act primary" data-open-issue="${escapeHTML(i.id)}" data-dtab="clarify">去澄清</button>${more}`;
if(stage.key==='waiting')return `<button type="button" class="issue-act primary" data-open-issue="${escapeHTML(i.id)}" data-dtab="sop">${run?.pauseRequested?'继续流程':'去确认'}</button>${more}`;
if(run?.status==='cancelled')return `${run?`<button type="button" class="issue-act" data-view-run="${escapeHTML(run.id)}">查看</button>`:''}${more}`;
if(run?.status==='failed'){
@@ -586,22 +575,22 @@ function issueCurrentStage(i){
if(!run){
if(issueClarifying(i.id))return{key:'active',label:'澄清分析中',hint:'关闭网页也不会中断,完成后可回来查看'};
if(clarificationNeedsConfirm(i)){
- const score=i.clarification?.score||0;
- return{key:'confirm',label:score?`待确认结论 · ${score} 分`:'待确认结论',hint:'确认写回原单(追加评论)后即可开始触发需求'};
- }
- if(requirementNeedsClarification(i)){
- const score=i.clarification?.score||0,threshold=clarificationPolicy((state.data.projects||[]).find(p=>p.id===i.projectId)).threshold||80;
- return{key:'attention',label:`待澄清 · ${score} 分`,hint:`未达准入线 ${threshold} 分,需要你补充信息`};
+ return{key:'confirm',label:'待确认结论',hint:'确认写回原单(追加评论)后即可开始触发需求'};
}
if(task&&['queued','dispatched','running'].includes(task.status)){
return{key:'active',label:task.status==='queued'?'排队中':'运行中',hint:'任务已调度,正在准备执行工作区与 Agent 环境'};
}
if((i.status||'')==='done')return{key:'closed',label:'已完成',hint:'需求已完成'};
+ // Questions are waiting for answers. Informational only: it neither
+ // counts as 需要介入 nor blocks triggering the SOP.
+ if(i.clarification?.status==='in_progress'&&(i.clarification.questions||[]).length){
+ return{key:'clarifying',label:'待澄清',hint:'澄清问题等待回答,不影响直接触发 SOP'};
+ }
if(i.kind==='requirement'){
- const score=i.clarification?.score||0,ready=i.clarification?.status==='ready'||i.clarification?.passed;
+ const ready=i.clarification?.status==='ready';
const multi=issueLaneStage(i);
if(multi)return multi;
- return{key:'not_started',label:ready?(score?`澄清完成 · ${score} 分`:'澄清已通过'):'等待执行',hint:ready?'可以进入研发 SOP':'尚未创建运行'};
+ return{key:'not_started',label:ready?'澄清已完成':'等待执行',hint:ready?'可以进入研发 SOP':'尚未创建运行'};
}
return{key:'not_started',label:'等待执行',hint:'尚未创建运行'};
}
diff --git a/web/app/issues.js b/web/app/issues.js
index 9b5963d8..68724915 100644
--- a/web/app/issues.js
+++ b/web/app/issues.js
@@ -155,7 +155,7 @@ function renderIssues(){
return;
}
const emptyTitle=state.issueRunFilter==='attention'?'没有需要介入的工作项':state.issueRunFilter==='mr'?'没有待处理 MR 的需求':'当前项目没有匹配的工作项';
- const emptyHint=state.issueRunFilter==='attention'?'澄清未达标、门禁失败、运行失败或已中断的工作项会显示在这里。':state.issueRunFilter==='mr'?'已提 MR 但还没合入的需求会显示在这里。':'从 GitHub 同步,或在本平台新建需求。';
+ const emptyHint=state.issueRunFilter==='attention'?'待确认澄清结论、门禁失败、运行失败或已中断的工作项会显示在这里。':state.issueRunFilter==='mr'?'已提 MR 但还没合入的需求会显示在这里。':'从 GitHub 同步,或在本平台新建需求。';
const keyWidth=issueKeyColumnWidth(paged.items);
const pager=pagerHTML('issues',paged)||(paged.total?`<nav class="pager pager-summary" aria-label="分页"><span class="pager-meta">共 ${paged.total} 条</span></nav>`:'');
board.innerHTML=`<div class="issue-table-card"><div class="issue-table-scroll"><div class="issue-table${state.issueSelectionMode?' issue-table-selectable':''}" data-page-anchor="issues" style="--issue-col-key:${keyWidth}"><div class="issue-table-row issue-table-head" role="row">${state.issueSelectionMode?`<div class="issue-select-cell">${issueSelectAllCheckbox('全选本页可删除的需求')}</div>`:''}<span>编号</span><span>标题</span><span>来源</span><span>责任人</span><span>仓库</span><span>优先级</span><span>关联 SOP</span><span>当前环节</span><span>进度</span><span>操作</span></div><div class="issue-table-body">${paged.items.map(issueRow).join('')||`<div class="issue-table-empty">${huiIcon('search')}<b>${emptyTitle}</b><p>${emptyHint}</p></div>`}</div></div></div>${pager}</div>`;
@@ -245,14 +245,14 @@ function bindIssueKanban(){
function issueStatusLabel(value){return ({backlog:'待规划',todo:'待处理',in_progress:'进行中',in_review:'评审中',done:'已完成',blocked:'已阻塞',cancelled:'已取消',closed:'已关闭'}[value]||value||'—')}
function issueStatusIcon(value){return ({backlog:'circle',todo:'clock',in_progress:'user-hold',in_review:'pending-review',done:'check',closed:'close',blocked:'alert',cancelled:'close'}[value]||'circle')}
function huiIcon(name,cls=''){return `<svg class="agent-icon harness-icon${cls?` ${cls}`:''}" data-icon="${escapeHTML(name)}" width="14" height="14" aria-hidden="true" focusable="false"></svg>`}
-// stage.key alone is not enough: 「待澄清」 shares attention with failures and
-// 「已关闭」 shares closed with merged deliveries.
+// stage.key alone is not enough: 「已关闭」 shares closed with merged deliveries.
function issueStageTone(stage){
const key=stage?.key||'',label=String(stage?.label||'');
if(key==='active')return /排队/.test(label)?{tone:'info',icon:'clock'}:{tone:'info',icon:'lamp'};
if(key==='waiting')return {tone:'warn',icon:'user-hold'};
if(key==='confirm')return {tone:'warn',icon:'pending-review'};
- if(key==='attention')return label.startsWith('待澄清')?{tone:'warn',icon:'user-hold'}:{tone:'error',icon:'alert'};
+ if(key==='clarifying')return {tone:'warn',icon:'user-hold'};
+ if(key==='attention')return {tone:'error',icon:'alert'};
if(key==='closed')return ['已完成','交付闭环','MR 已合入','已合入基线'].includes(label)?{tone:'success',icon:'check'}:{tone:'neutral',icon:'close'};
return {tone:'neutral',icon:'circle'};
}
@@ -301,7 +301,7 @@ function issueWaitingToExecute(i){
// 已阻塞必须留在各自的状态筛选中,即使它们暂时没有 Run。
if(status!=='backlog')return false;
const stage=issueCurrentStage(i);
- return stage.key==='not_started'||stage.label==='等待执行';
+ return stage.key==='not_started'||stage.key==='clarifying'||stage.label==='等待执行';
}
function issueFinished(i){
if(!i)return false;
@@ -385,7 +385,6 @@ function issueRow(i){
const convo=conversationIssueProgress(i,run);
const isFailed=!conversationWorkspaceIssue(i,run)&&Boolean(run&&(['failed','cancelled'].includes(run.status)||issueHasFailedNode(run)));
const needsConfirm=clarificationNeedsConfirm(i);
- const needsClarify=requirementNeedsClarification(i);
let progressText=`${progress.pct}%`;
let progressCls='';
let progressTitle=`${progress.done}/${progress.total||0} 节点`;
@@ -403,13 +402,8 @@ function issueRow(i){
}else if(needsConfirm){
progressText='需要确认结论';
progressCls=' confirm';
- trackWidth=Math.min(100,Math.max(20,i.clarification?.score||100));
- progressTitle=`澄清已完成(${i.clarification?.score||80} 分),需要确认结论后再触发 SOP`;
- }else if(needsClarify){
- progressText='待澄清';
- progressCls=' warn';
- trackWidth=0;
- progressTitle=`信息完整度 ${i.clarification?.score||0} 分,未达准入线,需先澄清`;
+ trackWidth=100;
+ progressTitle='澄清已完成,需要确认结论后再触发 SOP';
}else if(progress.pct>=100){
progressCls=' done';
}
@@ -684,14 +678,8 @@ async function importTAPDStory(e){
if(idx>=0)state.data.issues[idx]=issue;else (state.data.issues||(state.data.issues=[])).unshift(issue);
$('#importTAPDModal').classList.remove('open');
renderIssues();
- if(requirementNeedsClarification(issue)){
- state.autoStartClarify=true;
- toast(`已导入:${issue.title||issue.id}。评分 ${issue.clarification?.score||0} 分,需要你补充澄清`,'ok');
- openIssueDetail(issue.id,'clarify');
- }else{
- toast(`已导入 TAPD 工作项:${issue.title||issue.id}`,'ok');
- if(issue.id)openIssueDetail(issue.id);
- }
+ toast(`已导入 TAPD 工作项:${issue.title||issue.id}`,'ok');
+ if(issue.id)openIssueDetail(issue.id);
}catch(err){toast(err.message)}
finally{if(button){button.disabled=false;button.textContent='导入'}}
}
@@ -727,7 +715,7 @@ async function persistIssue(issue){
async function saveIssue(e){e.preventDefault();const button=e.currentTarget.querySelector('button[type="submit"]');try{button.disabled=true;button.textContent='正在保存…';const saved=await persistIssue(issueFromForm());state.selectedIssue=saved.id;$('#issueModal').classList.remove('open');renderIssues();toast('需求已保存')}catch(err){toast(err.message)}finally{button.disabled=false;button.textContent='保存'}}
async function dispatchIssue(){try{let issue=issueFromForm();const blocked=issueExecutionBlocked(issue);if(blocked)return toast(blocked);const current=latestIssueTask(issue),rerun=!!current;if(current&&!await afConfirm({title:'重新运行确认',message:['queued','dispatched','running'].includes(current.status)?'该需求已有进行中的任务,确定额外发起一次重新运行吗?':'该需求已经处理过,确定整条 SOP 重新运行吗?',confirmText:'确认重新运行'}))return;const button=$('#dispatchIssue');button.disabled=true;button.textContent='正在调度…';issue=await persistIssue(issue);const task=await api(`/api/issues/${issue.id}/dispatch`,{method:'POST',body:JSON.stringify({rerun,workflowId:issue.workflowId||''})});issue.latestTaskId=task.id;issue.status='in_progress';const idx=state.data.issues.findIndex(i=>i.id===issue.id);if(idx>=0)state.data.issues[idx]=issue;if(!state.data.tasks)state.data.tasks=[];const existingTaskIdx=state.data.tasks.findIndex(t=>t.id===task.id);if(existingTaskIdx>=0)state.data.tasks[existingTaskIdx]=task;else state.data.tasks.unshift(task);if(task.runId){startLiveRun(task.runId);try{const run=await api(`/api/runs/${encodeURIComponent(task.runId)}`,{silent:true});if(run?.id){if(!state.data.runs)state.data.runs=[];const rIdx=state.data.runs.findIndex(r=>r.id===run.id);if(rIdx>=0)state.data.runs[rIdx]={...state.data.runs[rIdx],...run};else state.data.runs=sortRunsDescending([run,...state.data.runs]);}}catch(e){}}$('#issueModal').classList.remove('open');renderIssues();await openIssueDetail(issue.id,'sop');toast(rerun?'已创建重新运行':'已创建执行任务并启动工作流','ok');Promise.all([refreshIssues(),refreshRuns(true)]).catch(()=>{});}catch(err){toast(err.message)}finally{const button=$('#dispatchIssue');button.disabled=false;button.textContent='启动 SOP'}}
async function dispatchIssueById(issueId,rerun=false,workflowId=''){try{const issue=(state.data.issues||[]).find(i=>i.id===issueId),blocked=issueExecutionBlocked(issue);if(blocked)return toast(blocked);if(clarificationNeedsConfirm(issue)){openIssueDetail(issueId,'clarify');return toast('请先确认澄清结论后再触发 SOP')}
- if(requirementNeedsClarification(issue)){state.autoStartClarify=true;openIssueDetail(issueId,'clarify');return toast('需求澄清未达标,请先补充关键信息')}const task=await api(`/api/issues/${issueId}/dispatch`,{method:'POST',body:JSON.stringify({rerun,workflowId})});if(issue){issue.latestTaskId=task.id;issue.status='in_progress'}if(!state.data.tasks)state.data.tasks=[];const existingTaskIdx=state.data.tasks.findIndex(t=>t.id===task.id);if(existingTaskIdx>=0)state.data.tasks[existingTaskIdx]=task;else state.data.tasks.unshift(task);if(task.runId){startLiveRun(task.runId);try{const run=await api(`/api/runs/${encodeURIComponent(task.runId)}`,{silent:true});if(run?.id){if(!state.data.runs)state.data.runs=[];const rIdx=state.data.runs.findIndex(r=>r.id===run.id);if(rIdx>=0)state.data.runs[rIdx]={...state.data.runs[rIdx],...run};else state.data.runs=sortRunsDescending([run,...state.data.runs]);}}catch(e){}}renderIssues();await openIssueDetail(issueId,'sop');toast(rerun?'已创建重新运行':'已启动 SOP','ok');Promise.all([refreshIssues(),refreshRuns(true)]).catch(()=>{});setTimeout(()=>refreshIssues(),2000);setTimeout(()=>refreshIssues(),10000);}catch(err){if(/澄清/.test(err.message||'')){state.issueDetailTab='clarify';openIssueDetail(issueId,'clarify')}toast(err.message,'err')}}
+const task=await api(`/api/issues/${issueId}/dispatch`,{method:'POST',body:JSON.stringify({rerun,workflowId})});if(issue){issue.latestTaskId=task.id;issue.status='in_progress'}if(!state.data.tasks)state.data.tasks=[];const existingTaskIdx=state.data.tasks.findIndex(t=>t.id===task.id);if(existingTaskIdx>=0)state.data.tasks[existingTaskIdx]=task;else state.data.tasks.unshift(task);if(task.runId){startLiveRun(task.runId);try{const run=await api(`/api/runs/${encodeURIComponent(task.runId)}`,{silent:true});if(run?.id){if(!state.data.runs)state.data.runs=[];const rIdx=state.data.runs.findIndex(r=>r.id===run.id);if(rIdx>=0)state.data.runs[rIdx]={...state.data.runs[rIdx],...run};else state.data.runs=sortRunsDescending([run,...state.data.runs]);}}catch(e){}}renderIssues();await openIssueDetail(issueId,'sop');toast(rerun?'已创建重新运行':'已启动 SOP','ok');Promise.all([refreshIssues(),refreshRuns(true)]).catch(()=>{});setTimeout(()=>refreshIssues(),2000);setTimeout(()=>refreshIssues(),10000);}catch(err){if(/澄清/.test(err.message||'')){state.issueDetailTab='clarify';openIssueDetail(issueId,'clarify')}toast(err.message,'err')}}
function defaultSOPForIssue(issue){
const projectId=issue?.projectId||state.projectFilter;
const project=(state.data.projects||[]).find(p=>p.id===projectId);
@@ -778,11 +766,6 @@ async function triggerIssue(issueId,workflowId){
const issue=(state.data.issues||[]).find(i=>i.id===issueId);
if(!issue)return toast('未找到工作项');
const blocked=issueExecutionBlocked(issue);if(blocked)return toast(blocked);
- if(requirementNeedsClarification(issue)){
- state.autoStartClarify=true;
- openIssueDetail(issue.id,'clarify');
- return toast('需求澄清未达标,请先补充关键信息');
- }
const targetWorkflow=String(workflowId||'').trim()||issue.workflowId||defaultSOPForIssue(issue);
const laneTask=(state.data.tasks||[]).find(t=>t.issueId===issue.id&&t.workflowId===targetWorkflow);
const latestRun=laneTask?latestIssueRun(issue,laneTask):null;
@@ -842,9 +825,9 @@ async function retriggerIssue(issueId,workflowId){
if(!issue)return toast('未找到工作项');
if(issueTrackerClosed(issue))return toast('外部工作项已关闭,请先在外部系统重新打开');
if(issueManuallyClosed(issue))return toast('请先重新打开该需求,再触发 SOP');
- if(requirementNeedsClarification(issue)||clarificationNeedsConfirm(issue)){
+ if(clarificationNeedsConfirm(issue)){
openIssueDetail(issue.id,'clarify');
- return toast('请先完成澄清再重新触发');
+ return toast('请先确认澄清结论再重新触发');
}
if(!await afConfirm({title:'重新触发确认',message:'会整条 SOP 从头再开一条新运行,已完成步骤也会重做,旧记录还在。失败时若只想从失败点继续,请用「重试」。',confirmText:'确认重新触发'}))return;
try{
diff --git a/web/app/projects.js b/web/app/projects.js
index 0c73c305..97717c06 100644
--- a/web/app/projects.js
+++ b/web/app/projects.js
@@ -11,20 +11,9 @@ function renderProjectContext(projectIssues){
$('#projectContextName').textContent=project?.name||'暂无项目';$('#projectContextDescription').textContent=project?.description||'工作台数据会按项目整体切换';
const active=projectIssues.filter(i=>issueRunHealth(i)==='active').length,attention=projectIssues.filter(i=>issueRunHealth(i)==='attention').length,pendingMRs=projectIssues.reduce((n,i)=>n+pendingDeliveryMRCount(i),0),repo=(state.data.repositories||[]).find(r=>r.id===project?.defaultRepositoryId);
const repoCount=(state.data.repositories||[]).filter(r=>r.projectId===project?.id).length;
- $('#projectContextMetrics').innerHTML=`<button type="button" data-issue-filter="" class="${!state.issueRunFilter?'on':''}"><span>工作项</span><b>${projectIssues.length}</b></button><button type="button" data-issue-filter="active" class="${state.issueRunFilter==='active'?'on':''}"><span>正在推进</span><b>${active}</b></button><button type="button" data-issue-filter="attention" class="${attention?'danger':''} ${state.issueRunFilter==='attention'?'on':''}" title="点此只看澄清未达标、门禁失败、运行失败或已中断的工作项"><span>需要介入</span><b>${attention}</b></button><button type="button" data-issue-filter="mr" class="${state.issueRunFilter==='mr'?'on':''}" title="已提 MR 但还没合入的 MR 数(按 MR 计,点击只看涉及的需求)"><span>待处理 MR</span><b>${pendingMRs}</b></button><div class="project-default-sop"><span>代码仓库(${repoCount})</span><b title="${escapeHTML(repo?.gongfengProjectId||'未绑定')}">默认:${escapeHTML(repo?.name||'未绑定')}</b></div>`;
+ $('#projectContextMetrics').innerHTML=`<button type="button" data-issue-filter="" class="${!state.issueRunFilter?'on':''}"><span>工作项</span><b>${projectIssues.length}</b></button><button type="button" data-issue-filter="active" class="${state.issueRunFilter==='active'?'on':''}"><span>正在推进</span><b>${active}</b></button><button type="button" data-issue-filter="attention" class="${attention?'danger':''} ${state.issueRunFilter==='attention'?'on':''}" title="点此只看待确认澄清结论、门禁失败、运行失败或已中断的工作项"><span>需要介入</span><b>${attention}</b></button><button type="button" data-issue-filter="mr" class="${state.issueRunFilter==='mr'?'on':''}" title="已提 MR 但还没合入的 MR 数(按 MR 计,点击只看涉及的需求)"><span>待处理 MR</span><b>${pendingMRs}</b></button><div class="project-default-sop"><span>代码仓库(${repoCount})</span><b title="${escapeHTML(repo?.gongfengProjectId||'未绑定')}">默认:${escapeHTML(repo?.name||'未绑定')}</b></div>`;
$('#projectContextMetrics').querySelectorAll('[data-issue-filter]').forEach(btn=>btn.onclick=()=>setIssueRunFilter(btn.dataset.issueFilter));
}
-function defaultClarification(){return{enabled:true,skillId:'requirement-clarification',threshold:80,dimensions:[{id:'goal',name:'目标与价值',question:'要解决什么问题,预期产生什么业务价值?',weight:20,minLength:30},{id:'user',name:'用户与场景',question:'谁会在什么场景下使用?',weight:15,minLength:20},{id:'scope',name:'范围与边界',question:'本次包含什么、不包含什么?',weight:20,minLength:30},{id:'acceptance',name:'验收标准',question:'如何用可测试的条件判断需求完成?',weight:25,minLength:40},{id:'constraints',name:'约束与依赖',question:'有哪些技术约束、依赖、风险或截止时间?',weight:20,minLength:25}]}}
-function clarificationPolicy(project){return project?.clarification?.dimensions?.length?project.clarification:defaultClarification()}
-function requirementNeedsClarification(i){
- if(!i||i.kind!=='requirement')return false;
- if(!i.clarification?.gated)return false;
- if(i.clarification?.status==='analyzing'||i.clarification?.status==='ready')return false;
- if(latestIssueTask(i)||latestIssueRun(i))return false;
- const project=(state.data.projects||[]).find(p=>p.id===i.projectId);
- if(!clarificationPolicy(project).enabled)return false;
- return !i.clarification?.passed;
-}
function clarificationNeedsConfirm(i){
const c=i?.clarification||{};
if(c.status!=='ready')return false;
@@ -115,7 +104,7 @@ function parseProjectAdminRoute(hash){
}
function projectAdminHash(id,tab){return id?`#/projects/${encodeURIComponent(id)}${id!=='new'&&tab&&tab!=='basic'?'/'+tab:''}`:'#/projects'}
function projectPeopleIds(p){return [...new Set([p?.ownerId,...(p?.members||[]).map(m=>m.userId)].map(Number).filter(Boolean))]}
-function blankProjectDraft(){return {id:'',key:'',name:'',description:'',color:PROJECT_SWATCHES[0],ownerId:Number(state.currentUser?.id)||'',workflowId:'generic-backend-delivery',defaultRepositoryId:'',businessDomainId:'',members:[],clarification:defaultClarification(),runEval:defaultRunEval(),tapdWorkspaceId:'',tapdIterationId:'',tapdClear:false}}
+function blankProjectDraft(){return {id:'',key:'',name:'',description:'',color:PROJECT_SWATCHES[0],ownerId:Number(state.currentUser?.id)||'',workflowId:'generic-backend-delivery',defaultRepositoryId:'',businessDomainId:'',members:[],runEval:defaultRunEval(),tapdWorkspaceId:'',tapdIterationId:'',tapdClear:false}}
function projectDraftFrom(project){const d=clone(project)||{};d.members=(d.members||[]).filter(m=>Number(m.userId)!==Number(d.ownerId)).map(m=>({userId:Number(m.userId)||0,role:'member'}));d.tapdClear=false;return d}
function projectDraftSignature(d){
d=d||{};
@@ -519,7 +508,7 @@ function applyProjectDefaultSOP(project,workflowId){
function buildProjectPayload(base,fields={}){
base=base||{};
const ownerId=Number(fields.ownerId??base.ownerId)||0,id=String(fields.id??base.id??'').trim(),rawDefault=String(fields.defaultRepositoryId??base.defaultRepositoryId??'');
- const value={...base,id,key:String(fields.key??base.key??'').trim().toUpperCase(),name:String(fields.name??base.name??'').trim(),description:fields.description??base.description??'',color:fields.color||base.color||PROJECT_SWATCHES[0],ownerId,workflowId:fields.workflowId??base.workflowId??'',defaultRepositoryId:rawDefault&&(state.data.repositories||[]).some(r=>r.id===rawDefault&&r.projectId===id)?rawDefault:'',members:(fields.members??base.members??[]).map(m=>({userId:Number(m.userId)||0,role:'member'})).filter(m=>m.userId!==ownerId),clarification:base.clarification||defaultClarification(),runEval:base.runEval,tapdWorkspaceId:String(fields.tapdWorkspaceId??base.tapdWorkspaceId??'').trim(),tapdIterationId:String(fields.tapdIterationId??base.tapdIterationId??'').trim()};
+ const value={...base,id,key:String(fields.key??base.key??'').trim().toUpperCase(),name:String(fields.name??base.name??'').trim(),description:fields.description??base.description??'',color:fields.color||base.color||PROJECT_SWATCHES[0],ownerId,workflowId:fields.workflowId??base.workflowId??'',defaultRepositoryId:rawDefault&&(state.data.repositories||[]).some(r=>r.id===rawDefault&&r.projectId===id)?rawDefault:'',members:(fields.members??base.members??[]).map(m=>({userId:Number(m.userId)||0,role:'member'})).filter(m=>m.userId!==ownerId),runEval:base.runEval,tapdWorkspaceId:String(fields.tapdWorkspaceId??base.tapdWorkspaceId??'').trim(),tapdIterationId:String(fields.tapdIterationId??base.tapdIterationId??'').trim()};
applyProjectDefaultSOP(value,value.workflowId);
for(const k of ['businessDomainId','tapdClear','repoRows','repoDrafts','gitToken','codeBuddyApiKey','codeBuddyInternetEnvironment'])delete value[k];
if(fields.tapdClear)value.tapdClear=true;
diff --git a/web/app/requirement-wizard.css b/web/app/requirement-wizard.css
index 58e29177..7865d974 100644
--- a/web/app/requirement-wizard.css
+++ b/web/app/requirement-wizard.css
@@ -538,16 +538,6 @@
#requirementModal .req-ready-head { display: flex; align-items: center; gap: 8px; padding: 12px 14px; border-bottom: 1px solid var(--hui-border-soft); font-weight: 500; }
#requirementModal .req-ready-head .harness-icon { color: var(--hui-success); }
#requirementModal .req-ready-body { padding: 12px 14px; color: var(--hui-secondary); font-size: 13px; line-height: 1.7; white-space: pre-wrap; }
-#requirementModal .req-score-details { padding: 0 14px 8px; border-top: 1px solid var(--hui-border-soft); }
-#requirementModal .req-score-wrap .req-score-details { margin-top: 16px; padding: 0; border-top: 0; }
-#requirementModal .req-score-body { padding: 6px 0 4px; }
-#requirementModal .req-dim { display: grid; grid-template-columns: 96px 1fr 34px; align-items: center; gap: 10px; padding: 4px 0; color: var(--hui-muted); font-size: 12px; }
-#requirementModal .req-dim b { color: var(--hui-text); font-weight: 500; text-align: right; font-variant-numeric: tabular-nums; }
-#requirementModal .req-meter { position: relative; height: 4px; overflow: hidden; border-radius: 2px; background: var(--hui-soft); }
-#requirementModal .req-meter i { position: absolute; inset: 0 auto 0 0; border-radius: 2px; background: color-mix(in srgb, var(--hui-accent) 70%, transparent); }
-#requirementModal .req-dim-total { margin-top: 4px; padding-top: 8px; border-top: 1px solid var(--hui-border-soft); color: var(--hui-text); }
-#requirementModal .req-dim-line { color: var(--hui-tertiary); font-size: 11.5px; }
-#requirementModal .req-dim-missing { padding-top: 4px; color: var(--hui-muted); font-size: 12px; }
#requirementModal .req-supplement { margin-top: 14px; }
#requirementModal .req-supplement-label { margin-bottom: 6px; color: var(--hui-muted); font-size: 12px; }
diff --git a/web/app/workbench.js b/web/app/workbench.js
index a6ef586f..b926c88c 100644
--- a/web/app/workbench.js
+++ b/web/app/workbench.js
@@ -1719,7 +1719,7 @@ function renderDashboard(){
updateApprovalBadge();
const needMe=[...waiting,...confirm,...attention.filter(i=>!waiting.includes(i)&&!confirm.includes(i))];
const statCards=[
- {label:'需要介入',value:attention.length,foot:'澄清未达标、失败或已中断',color:'#c63c4b',filter:'attention'},
+ {label:'需要介入',value:attention.length,foot:'待确认结论、失败或已中断',color:'#c63c4b',filter:'attention'},
{label:'待我确认',value:approvalItems().length,foot:'批准后才会继续跑',color:'#fbbf24',to:'approvals'},
{label:'正在推进',value:active.length,foot:'Agent 正在执行',color:'#5b8cff',filter:'active'},
{label:'已经完成',value:closed.length,foot:'本项目已闭环',color:'#34d399',filter:'closed'},
diff --git a/web/clarification_composer_test.js b/web/clarification_composer_test.js
index 15c6c76e..94054543 100644
--- a/web/clarification_composer_test.js
+++ b/web/clarification_composer_test.js
@@ -13,7 +13,7 @@ const elements = {
const ctx = {
state:{},chatHistory:[],chatClarifySessionId:'',chatClarifyJobId:'',chatClarifyStopping:false,chatAbortController:null,reqAdvanceTimer:null,
$:s=>elements[s],$$:()=>[],window:{},setTimeout,clearTimeout,
- currentProject:()=>({id:'p'}),clarificationPolicy:()=>({threshold:80,dimensions:[{id:'goal',name:'目标',weight:1}]}),
+ currentProject:()=>({id:'p'}),
escapeHTML:s=>String(s),clarifyRepoNoticeHTML:()=>'',
clarifyThinkingReset:()=>{},persistRequirementComposer:()=>{persisted++},renderReqFooter:()=>{footer++},renderReqAnswerHistory:()=>{},
selectedReqRepositoryId:()=>'r1',selectedReqRepositoryIds:()=>['r1'],selectedReqBaseBranch:()=>'feature/existing',selectedClarifyModel:()=>'test',
@@ -24,8 +24,8 @@ const ctx = {
};
vm.createContext(ctx);
for(const name of [
- 'reqIcon','hydrateReqIcons','reqDescription','clarifyOptionLabel','clarifyQuestionOptions','composerClarifyQuestions','composerAssessmentView',
- 'reqAnswerOf','reqQuestionAnswered','reqAnsweredCount','composerProgressHTML','composerAssessmentDetailsHTML','collectChatReply',
+ 'reqIcon','hydrateReqIcons','reqDescription','clarifyOptionLabel','clarifyQuestionOptions','composerClarifyQuestions',
+ 'reqAnswerOf','reqQuestionAnswered','reqAnsweredCount','composerProgressHTML','collectChatReply',
'usableClarifySummary','reqSupplementHTML','reqQuestionCardHTML','renderClarifyPanel','bindReqClarifyPanel','pickReqOption','setReqOtherAnswer',
'moveReqQuestion','submitReqAnswers','useRecommendedAnswers','normalizeClarifyParsed','parseClarifyPayload',
'requirementComposerBusy','applyChatClarifyOutcome','sendChatClarify','newComposerJobId','finishComposerClarifyStream','setChatSendAnalyzing','reqAnswerReceipts','projectTAPDReady',
@@ -43,22 +43,14 @@ function show(result) {
ctx.renderClarifyPanel(result);
}
(async()=>{
- // Older responses with only missing items become free-text questions plus a regenerate action.
- const legacy={summary:'已读懂代码,需要确认修复目的和 ID 输入方式。',questions:[],ready:false,assessment:{missing:['修复目的是什么?','ID 怎么输入?']}};
+ // Older responses that only carried assessment.missing offer a regenerate action and free-form supplement; no scores.
+ const legacy={summary:'已读懂代码,需要确认修复目的和 ID 输入方式。',questions:[],ready:false,assessment:{dimensions:{goal:40},missing:['修复目的是什么?','ID 怎么输入?']}};
show(legacy);
assert.ok(panel.html.includes('重新生成问题'));
- assert.ok(panel.html.includes('第 1 / 2 题'));
- assert.ok(panel.html.includes('还有 2 个问题'));
- assert.ok(!panel.html.includes('查看完整度详情'), 'no ratings, no score details');
+ assert.ok(panel.html.includes('还需要补充说明'));
+ assert.ok(!panel.html.includes('查看完整度详情') && !panel.html.includes('准入线'), 'scores are never shown');
assert.ok(!/第 \d+ 轮|没有固定轮数/.test(panel.html));
- // Submitting with nothing answered warns and sends nothing.
- ctx.chatHistory=[{role:'user',content:'原始需求'}];
- ctx.state.reqQuestionIndex=1;
- await ctx.submitReqAnswers();
- assert.equal(requests.length,0);
- assert.ok(panel.html.includes('至少回答一题,或点「直接去创建」'));
-
// One question per card; single choice auto-advances, the last one auto-submits.
const choice={summary:'确认修复方式',ready:false,assessment:{dimensions:{goal:60},missing:['goal']},questions:[
{id:'q1',question:'重新推送?',options:['是','否']},
@@ -67,9 +59,17 @@ function show(result) {
show(choice);
assert.ok(panel.html.includes('第 1 / 2 题'));
assert.ok(panel.html.includes('id="reqNextQuestion"') && panel.html.includes('跳过此题'));
- assert.ok(panel.html.includes('查看完整度详情') && panel.html.includes('项目准入线 80'));
+ assert.ok(!panel.html.includes('查看完整度详情') && !panel.html.includes('准入线'));
assert.ok(!panel.html.includes('推荐'), 'no recommended tag without recommended options');
assert.ok(!panel.html.includes('全部用推荐答案'));
+ // Submitting with nothing answered warns and sends nothing.
+ ctx.chatHistory=[{role:'user',content:'原始需求'}];
+ ctx.state.reqQuestionIndex=1;
+ await ctx.submitReqAnswers();
+ assert.equal(requests.length,0);
+ assert.ok(panel.html.includes('至少回答一题,或点「直接去创建」'));
+ ctx.state.reqQuestionIndex=0;
+ ctx.renderClarifyPanel(choice);
ctx.pickReqOption(0);
assert.equal(ctx.state.reqQuestionIndex,0);
assert.ok(panel.html.includes('aria-checked="true"'));
diff --git a/web/i18n-en.js b/web/i18n-en.js
index 09222f17..9e1373b9 100644
--- a/web/i18n-en.js
+++ b/web/i18n-en.js
@@ -52,3 +52,27 @@ Object.assign(window.LF_I18N_EN,{
"AI 对话的 DeepSeek Harness 模型与以 DeepSeek Harness 运行的 SOP 节点":"DeepSeek Harness models in AI chat, and SOP steps that run on DeepSeek Harness",
"AI 对话的 ZCode 模型与以 ZCode 运行的 SOP 节点":"ZCode models in AI chat, and SOP steps that run on ZCode"
});
+Object.assign(window.LF_I18N_EN,{
+"继续回答关键问题,进度已经保存;不影响直接触发 SOP":"Keep answering the key questions. Progress is saved and does not block starting the SOP",
+"澄清问题等待回答,不影响直接触发 SOP":"Clarification questions are waiting for answers and do not block starting the SOP",
+"待确认澄清结论、门禁失败、运行失败或已中断的工作项会显示在这里。":"Items waiting for a clarification conclusion, a failed gate, or a failed or interrupted run show up here.",
+"点此只看待确认澄清结论、门禁失败、运行失败或已中断的工作项":"Show only items waiting for a clarification conclusion, a failed gate, or a failed or interrupted run",
+"待确认结论、失败或已中断":"Conclusion pending, failed, or interrupted",
+"已在平台创建需求,可在详情里触发 SOP":"Requirement created. Start the SOP from its details",
+"已在平台创建需求。澄清尚未完成,可在澄清页继续,也可以直接触发 SOP":"Requirement created. Clarification is unfinished; continue it, or start the SOP directly",
+"已在 TAPD 创建需求。澄清尚未完成,可在澄清页继续,也可以直接触发 SOP":"Requirement created in TAPD. Clarification is unfinished; continue it, or start the SOP directly",
+"澄清已完成 · 已写回 工蜂 Issue 评论":"Clarification complete · written back as a comment on the linked issue",
+"已写回 工蜂 Issue,可直接触发需求执行 SOP":"Written back to the linked issue. Start the SOP directly",
+"已澄清 · 已写回 工蜂":"Clarified · written back to the linked issue",
+"按澄清结论触发 SOP":"Start the SOP from the clarification",
+"可直接点击「触发需求」开始执行":"Click Start to run it now",
+"可选步骤。分析师只围绕这张单本身,结合本项目代码问清阻塞开工的细节;不澄清也可以直接触发 SOP。":"Optional. The analyst only asks what blocks this item, using this project's code. You can start the SOP without clarifying.",
+"每轮只问最关键的 1–3 个问题,只围绕这张单本身":"Each round asks only the 1–3 questions that matter, and only about this item",
+"回答后点「继续澄清」。分析师确认够用后会给出结论;也可以随时直接触发 SOP。":"After answering, click Continue clarifying. The analyst concludes when nothing blocks the work, and you can start the SOP at any time.",
+"澄清已完成,写回失败":"Clarification complete, write-back failed",
+"澄清已完成,待确认写回":"Clarification complete, write-back waiting for confirmation",
+"澄清已完成,需要确认结论后再触发 SOP":"Clarification complete. Confirm the conclusion before starting the SOP",
+"请先确认澄清结论再重新触发":"Confirm the clarification conclusion before retriggering",
+"结论已保存到平台说明,可直接触发需求执行 SOP":"The conclusion is saved on the platform description. Start the SOP directly",
+"可直接触发需求执行 SOP":"Start the SOP directly"
+});
diff --git a/web/issue_base_branch_test.js b/web/issue_base_branch_test.js
index cf0306dc..72d4d367 100644
--- a/web/issue_base_branch_test.js
+++ b/web/issue_base_branch_test.js
@@ -64,7 +64,7 @@ const ctx = {
ctx.renderReqRepositoryPicker();
},
projectTAPDReady: () => true, usableClarifySummary: s => s,
- renderIssues: () => {}, openIssueDetail: (id, tab) => opened.push([id, tab || ""]), openRunFromId: () => {}, requirementNeedsClarification: () => false,
+ renderIssues: () => {}, openIssueDetail: (id, tab) => opened.push([id, tab || ""]), openRunFromId: () => {},
toast: message => notices.push(message),
api: async (url, init) => {
const body = JSON.parse(init.body);
@@ -171,20 +171,21 @@ assert.equal(ctx.state.chatClarifyResult.ready, true);
assert.deepEqual(opened.at(-1), ["created", ""], "a skipped clarification opens the issue detail without dispatching");
ctx.state.reqClarifySkipped = false;
- ctx.state.chatClarifyResult = {ready: true, suggestedTitle: "继续开发", summary: "分析通过", assessment: {}};
+ ctx.state.chatClarifyResult = {ready: true, suggestedTitle: "继续开发", summary: "分析通过"};
elements["#reqTitle"].value = "确认页标题";
await ctx.createIssueFromChat("local");
const analyzed = requests.filter(request => request.url === "/api/issues").at(-1);
assert.equal(analyzed.body.baseBranch, "feature/continue");
assert.equal(analyzed.body.title, "确认页标题");
- assert.equal(analyzed.body.clarification.passed, true);
+ assert.equal(analyzed.body.clarification.status, "ready");
+ assert.equal(analyzed.body.clarification.passed, undefined, "no score/pass flag is sent");
assert.equal(requests.at(-1).url, "/api/issues/created/dispatch");
- ctx.state.chatClarifyResult = {ready: false, summary: "还差验收标准", questions: [{question: "验收?", options: []}], assessment: {}};
+ ctx.state.chatClarifyResult = {ready: false, summary: "还差验收标准", questions: [{question: "验收?", options: []}]};
const before = requests.length;
await ctx.createIssueFromChat("local");
assert.equal(requests.length, before + 1, "a not-ready conclusion creates the issue but does not dispatch");
- assert.equal(requests.at(-1).body.clarification.passed, false);
+ assert.equal(requests.at(-1).body.clarification.status, "in_progress");
assert.deepEqual(opened.at(-1), ["created", "clarify"]);
input.value = "";
diff --git a/web/issue_clarify_draft_test.js b/web/issue_clarify_draft_test.js
index 204f1965..6b1ea4ab 100644
--- a/web/issue_clarify_draft_test.js
+++ b/web/issue_clarify_draft_test.js
@@ -68,10 +68,8 @@ const flags = {analyzing: false};
const ctx = {
document: {get activeElement() { return active.current; }},
issueClarifying: () => flags.analyzing,
- requirementNeedsClarification: () => false,
clarificationNeedsConfirm: () => false,
issueExecutionBlocked: () => '',
- clarificationPolicy: () => ({threshold: 80}),
clarifyQuestionOptions: q => q.options || [],
escapeHTML: s => String(s ?? '').replace(/[&<>'"]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;',"'":'&#39;','"':'&quot;'}[c])),
CLARIFY_AUTO_PROMPTS: ['auto'],
@@ -85,7 +83,7 @@ for (const name of ['issueClarifyViewKey', 'clarifyQuestionKey', 'clarifySubmitt
const issue = {
id: 'dns-1', source: 'tapd', updatedAt: '2026-10-14T02:55:07Z',
clarification: {
- status: 'in_progress', score: 42,
+ status: 'in_progress',
questions: [{question: '预计涉及多少行?', options: ['50万行']}],
history: [{role: 'assistant', content: '{}'}]
}
@@ -94,7 +92,7 @@ const key = ctx.issueClarifyViewKey(issue, {id: 'p'});
const refreshed = JSON.parse(JSON.stringify(issue));
refreshed.updatedAt = '2026-10-14T03:01:00Z';
assert.equal(ctx.issueClarifyViewKey(refreshed, {id: 'p'}), key);
-refreshed.clarification.score = 80;
+refreshed.clarification.summary = '已有阶段结论';
assert.notEqual(ctx.issueClarifyViewKey(refreshed, {id: 'p'}), key);
const other = el({classes: ['issue-clarify-other'], value: '凌晨 2-5 点,约 50 万行', selectionStart: 2, selectionEnd: 2});
diff --git a/web/issues_list_test.js b/web/issues_list_test.js
index dd8dff3e..52ac130b 100644
--- a/web/issues_list_test.js
+++ b/web/issues_list_test.js
@@ -26,7 +26,7 @@ const tones = [
[{ key: 'active', label: '排队中' }, 'info', 'clock'],
[{ key: 'waiting', label: '方案设计' }, 'warn', 'user-hold'],
[{ key: 'confirm', label: '待确认结论 · 82 分' }, 'warn', 'pending-review'],
- [{ key: 'attention', label: '待澄清 · 47 分' }, 'warn', 'user-hold'],
+ [{ key: 'clarifying', label: '待澄清' }, 'warn', 'user-hold'],
[{ key: 'attention', label: '失败 · 编码实现' }, 'error', 'alert'],
[{ key: 'attention', label: '已取消 · 方案设计' }, 'error', 'alert'],
[{ key: 'closed', label: 'MR 已合入' }, 'success', 'check'],
diff --git a/web/platform.css b/web/platform.css
index 8584f123..93193908 100644
--- a/web/platform.css
+++ b/web/platform.css
@@ -276,7 +276,7 @@ button.issue-stat:hover{border-color:var(--line-strong);color:var(--text)}
.kanban-card h4{margin:0;color:var(--text);font-size:12.5px;line-height:1.35;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}
.kanban-card-meta{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-top:10px}
.kanban-stage{max-width:52%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--muted-2);font-size:10px}
-.kanban-stage.active{color:var(--blue)}.kanban-stage.waiting,.kanban-stage.confirm{color:var(--amber)}.kanban-stage.attention{color:var(--red)}.kanban-stage.closed{color:var(--green)}
+.kanban-stage.active{color:var(--blue)}.kanban-stage.waiting,.kanban-stage.confirm,.kanban-stage.clarifying{color:var(--amber)}.kanban-stage.attention{color:var(--red)}.kanban-stage.closed{color:var(--green)}
.kanban-card-progress{margin-top:10px}
.kanban-card-progress>span{display:block;margin-bottom:5px;color:var(--muted);font-size:10px}
.kanban-card-progress .issue-progress-track{height:4px}
@@ -416,7 +416,7 @@ html[data-theme="dark"] .issue-title-tag.tone-cyan{color:#67e8f9}
.issue-stage-cell{overflow:hidden;text-align:left}
.issue-stage-pill{max-width:100%;height:24px;padding:0 9px;display:inline-flex;align-items:center;border-radius:999px;border:1px solid var(--line);background:var(--panel-2);color:var(--muted);font-size:11px;font-weight:650;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
.issue-stage-cell.active .issue-stage-pill{background:var(--blue-soft);border-color:transparent;color:var(--blue)}
-.issue-stage-cell.waiting .issue-stage-pill,.issue-stage-cell.confirm .issue-stage-pill{background:rgba(251,191,36,.16);border-color:transparent;color:#b45309}
+.issue-stage-cell.waiting .issue-stage-pill,.issue-stage-cell.confirm .issue-stage-pill,.issue-stage-cell.clarifying .issue-stage-pill{background:rgba(251,191,36,.16);border-color:transparent;color:#b45309}
.issue-stage-cell.attention .issue-stage-pill{background:rgba(198,60,75,.12);border-color:transparent;color:#c63c4b}
.issue-stage-cell.closed .issue-stage-pill{background:rgba(52,211,153,.15);border-color:transparent;color:var(--green)}
.issue-progress-cell{display:flex;flex-direction:column;justify-content:center;gap:5px;min-width:0;color:var(--muted);font-size:12px;font-variant-numeric:tabular-nums}
diff --git a/web/product-v4.css b/web/product-v4.css
index fc8ca9af..99c5e425 100644
--- a/web/product-v4.css
+++ b/web/product-v4.css
@@ -1842,8 +1842,6 @@ html[data-theme="dark"] .agent-studio-v2{box-shadow:0 18px 56px rgba(0,0,0,.42),
.clarify-overview>div{min-width:0;flex:1}.clarify-overview b,.clarify-overview small{display:block}.clarify-overview small{margin-top:2px;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.clarify-overview.ready{border-color:color-mix(in srgb,#34d399 35%,var(--line));background:color-mix(in srgb,#34d399 7%,var(--panel))}
.clarify-overview.ready>span{background:color-mix(in srgb,#34d399 16%,transparent);color:#16a36a}
-.clarify-overview.needs-user{border-color:color-mix(in srgb,#fbbf24 55%,var(--line));background:color-mix(in srgb,#fbbf24 10%,var(--panel))}
-.clarify-overview.needs-user>span{background:color-mix(in srgb,#fbbf24 22%,transparent);color:#b76e00}
.clarify-check.warn{background:color-mix(in srgb,#fbbf24 22%,transparent);color:#b76e00}
.clarify-workspace{max-width:760px;margin:0 auto;padding:4px 0 28px}.clarify-workspace.clarify-empty{text-align:center;padding:48px 28px}
.clarify-orb{display:grid;place-items:center;width:54px;height:54px;margin:0 auto 14px;border-radius:18px;background:linear-gradient(135deg,var(--blue-soft),color-mix(in srgb,#8b5cf6 18%,transparent));color:var(--blue);font-size:25px;font-weight:800}
@@ -2000,12 +1998,6 @@ html[data-theme="dark"] .agent-studio-v2{box-shadow:0 18px 56px rgba(0,0,0,.42),
.issue-clarify-other{width:100%;box-sizing:border-box;margin-top:9px;padding:9px 10px;border:1px solid var(--line);border-radius:9px;background:var(--panel);color:var(--text)}
.issue-clarify-composer{margin-top:14px;padding:12px;border:1px solid var(--line);border-radius:12px;background:var(--panel)}.issue-clarify-composer textarea{width:100%;box-sizing:border-box;resize:vertical;border:0;outline:0;background:transparent;color:var(--text);font:inherit}.issue-clarify-composer>div{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-top:8px}.issue-clarify-composer span{color:var(--muted);font-size:11px}
/* Clarification quality: informational only, never a gate. */
-.clarify-score{display:flex;gap:14px;margin-top:12px;padding:14px;border:1px solid var(--line);border-radius:12px;background:var(--panel)}
-.clarify-score-total{display:grid;place-content:center;flex:0 0 78px;height:78px;border-radius:12px;background:var(--panel-2);text-align:center}
-.clarify-score-total b{font-size:26px;line-height:1.1}.clarify-score-total span{display:block;margin-top:2px;color:var(--muted-2);font-size:10px}
-.clarify-score-total.good b{color:#16a36a}.clarify-score-total.fair b{color:#b76e00}.clarify-score-total.weak b{color:#dc5151}
-.clarify-score-body{flex:1;min-width:0;display:flex;flex-direction:column;justify-content:center;gap:7px}
-.clarify-score-body>small{color:var(--muted-2);font-size:11px}
.clarify-bar{display:flex;align-items:center;gap:8px;font-size:12px}.clarify-bar>span{flex:0 0 92px;color:var(--muted)}.clarify-bar>i{flex:1;height:6px;border-radius:999px;background:var(--panel-3);overflow:hidden}.clarify-bar>i>b{display:block;height:100%;background:var(--blue)}.clarify-bar>em{flex:0 0 28px;text-align:right;font-style:normal;font-variant-numeric:tabular-nums}
/* ==================== 智能评测与架构巡检 面板 2.0 ==================== */
.run-eval-section {
@@ -2666,19 +2658,6 @@ html[data-theme="dark"] .agent-studio-v2{box-shadow:0 18px 56px rgba(0,0,0,.42),
grid-template-columns: 1fr;
}
}
-.clarify-rate{display:flex;align-items:center;gap:10px;font-size:12px}
-.clarify-rate>span{flex:0 0 86px;color:var(--muted)}
-.clarify-rate>i{flex:1;height:6px;border-radius:999px;background:var(--panel-3);overflow:hidden}
-.clarify-rate>i>b{display:block;height:100%;border-radius:999px;background:#34d399}
-.clarify-rate>i>b.fair{background:#fbbf24}.clarify-rate>i>b.weak{background:#f87171}
-.clarify-rate>em{flex:0 0 26px;text-align:right;font-style:normal;color:var(--muted);font-variant-numeric:tabular-nums}
-.clarify-missing{margin-top:10px;padding:12px 14px;border:1px solid color-mix(in srgb,#fbbf24 35%,var(--line));border-radius:12px;background:color-mix(in srgb,#fbbf24 7%,var(--panel))}
-.clarify-missing-head{display:flex;align-items:center;gap:6px;margin-bottom:8px;color:#b76e00}
-html[data-theme="dark"] .clarify-missing-head{color:var(--amber,#fbbf24)}
-.clarify-missing-head b{font-size:12px;font-weight:650;color:var(--text)}
-.clarify-missing-list{display:flex;flex-wrap:wrap;gap:8px}
-.clarify-missing-chip{display:inline-flex;align-items:center;gap:6px;padding:5px 11px;border-radius:999px;background:var(--panel);border:1px solid color-mix(in srgb,#fbbf24 40%,var(--line));font-size:12px;color:var(--text);line-height:1.3}
-.clarify-missing-chip i{width:6px;height:6px;border-radius:50%;background:#f59e0b;flex-shrink:0}
.clarify-history{margin-top:12px;border:1px solid var(--line);border-radius:12px;background:var(--panel)}
.clarify-history>summary{padding:11px 14px;color:var(--muted);font-size:12px;cursor:pointer;list-style:none}
.clarify-history>summary::-webkit-details-marker{display:none}
diff --git a/web/project_default_sop_test.js b/web/project_default_sop_test.js
index e9bb6fe3..bf7f439b 100644
--- a/web/project_default_sop_test.js
+++ b/web/project_default_sop_test.js
@@ -13,7 +13,7 @@ const ctx = {
{id:"generic-backend-delivery",name:"Backend",generic:true},
]}},
escapeHTML:s=>String(s).replace(/[&<>"]/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;"}[c])),
- clone:v=>JSON.parse(JSON.stringify(v)),captureRepoRows:()=>{},defaultClarification:()=>({}),
+ clone:v=>JSON.parse(JSON.stringify(v)),captureRepoRows:()=>{},
toast:s=>notices.push(s),renderAll:()=>{},localStorage:{setItem:()=>{}},
api:async(url,init)=>{const body=JSON.parse(init.body);requests.push({url,body});return body;},
};
diff --git a/web/syntax_test.go b/web/syntax_test.go
index 3e1c0fda..ff173395 100644
--- a/web/syntax_test.go
+++ b/web/syntax_test.go
@@ -82,7 +82,6 @@ const issueTrackerClosed = () => false;
const deliveryLocked = () => false;
const issueClarifying = () => false;
const clarificationNeedsConfirm = () => false;
-const requirementNeedsClarification = () => false;
const conversationWorkspaceIssue = () => false;
const isScriptWorkflowNode = node => node?.type==='script'||node?.type==='command';
const cachedRun = () => null;
@@ -1330,17 +1329,17 @@ func TestRequirementDirectCreateUI(t *testing.T) {
}
for _, want := range []string{
`function goReqStep(`, `function renderReqSteps(`, `function renderReqFooter(`, `function renderReqConfirm(`, `function renderReqRepoChip(`, `function pickReqOption(`, `function submitReqAnswers(`, `function reclarifyRequirement(`,
- `reqCreateDirect`, `reqCreateAccepted`, `不会立刻启动`, `persistRequirementComposer`, `agentflow.requirementComposer`, `未配置`, `if(modal.id==='requirementModal')return`,
+ `reqCreateDirect`, `reqCreateAccepted`, `可在详情里触发 SOP`, `persistRequirementComposer`, `agentflow.requirementComposer`, `未配置`, `if(modal.id==='requirementModal')return`,
`resumeChatClarify`, `jobId:chatClarifyJobId`, `正在接上分析`, `从空白开始`, `stripClarifyReason`, `renderClarifyPanel(JSON.parse(lastAssistant.content))`,
`assigneeUserId:Number(state.currentUser?.id)||0`, `fillReqWorkflow`, `selectedReqWorkflowId`, `workflowId:selectedReqWorkflowId()`, `composerProgressHTML`,
- `已问清,可以创建`, `查看完整度详情`, `至少回答一题,或点「直接去创建」`, `提交回答`, `跳过此题`, `上一题`, `你的回答`, `全部用推荐答案`, `下一步:确认创建`, `澄清基于原仓库`, `重新澄清`, `· 已跳过`,
+ `已问清,可以创建`, `至少回答一题,或点「直接去创建」`, `提交回答`, `跳过此题`, `上一题`, `你的回答`, `全部用推荐答案`, `下一步:确认创建`, `澄清基于原仓库`, `重新澄清`, `· 已跳过`,
`questionIndex:`, `answers:`, `repoSnapshot:`, `target:`, `step:`,
} {
if !strings.Contains(code, want) {
t.Fatalf("requirement wizard behavior is missing %q", want)
}
}
- for _, gone := range []string{`invalidateRequirementAnalysis`, `没有固定轮数`, `composerCreateReady`, `setComposerRetryMode`, `composerClarifyRetry`, `state.reqCreateMode`, `createIssueDirect`, `setChatCreateEnabled`, `syncReqComposerLayout`} {
+ for _, gone := range []string{`查看完整度详情`, `准入线`, `composerAssessmentView`, `invalidateRequirementAnalysis`, `没有固定轮数`, `composerCreateReady`, `setComposerRetryMode`, `composerClarifyRetry`, `state.reqCreateMode`, `createIssueDirect`, `setChatCreateEnabled`, `syncReqComposerLayout`} {
if strings.Contains(code, gone) {
t.Fatalf("requirement wizard must not keep %q", gone)
}
@@ -1420,7 +1419,7 @@ func TestTAPDImportUI(t *testing.T) {
t.Fatal(err)
}
code := string(js)
- for _, want := range []string{`/api/issues/import-tapd`, `openImportTAPDModal`, `fillImportTAPDWorkflow`, `fillImportTAPDRepository`, `selectedImportTAPDRepositoryIds`, `renderImportTAPDRepositoryPicker`, `repositoryIds`, `请至少选择一个代码仓库`, `importTAPDStory`, `requirementNeedsClarification`, `clarificationNeedsConfirm`, `data-dtab="clarify"`, `确认结论`, `clarification?.gated`, `autoStartClarify`, `issueClarifyJobs`, `attachIssueClarifyStream`, `关闭网页也不会中断`, `clarifyOptionLabel`, `clarifyQuestionOptions`, `createIssueFromChat`, `projectTAPDReady`, `reqCreate`, `setReqTarget`, `pushIssueToTAPDFromDetail`, `dashImportTAPD`, `run-id-copy`, `data-export-logs`, `从这里重跑`, `重新触发`, `data-retrigger-issue`, `data-rerun-from-here`, `canRetriggerIssue`, `openRerunFromNode`, `executionContext?.issueId`, `run?.status==='succeeded'`, `/api/issues/${encodeURIComponent(issueId)}/requirement`, `inferSOPLane`, `req-lane-card`, `issueLaneDots`, `.filter(l=>!l.orphan)`, `lanes.length<2`, `collapseSingleSOPLane`, `issueSOPLabel`, `actionWorkflow`, `data-workflow`, `workflowSOPLane`, `需求开发`, `saveIssueSOPS`, `/sops`, `effectiveIssueSOPBindings`, `projectSOPBindings`, `fillReqWorkflow`, `plannedSOPNodes`, `sopWorkflowId`, `sopWorkflowChoices`, `renderReqConfirm`} {
+ for _, want := range []string{`/api/issues/import-tapd`, `openImportTAPDModal`, `fillImportTAPDWorkflow`, `fillImportTAPDRepository`, `selectedImportTAPDRepositoryIds`, `renderImportTAPDRepositoryPicker`, `repositoryIds`, `请至少选择一个代码仓库`, `importTAPDStory`, `clarificationNeedsConfirm`, `data-dtab="clarify"`, `确认结论`, `issueClarifyJobs`, `attachIssueClarifyStream`, `关闭网页也不会中断`, `clarifyOptionLabel`, `clarifyQuestionOptions`, `createIssueFromChat`, `projectTAPDReady`, `reqCreate`, `setReqTarget`, `pushIssueToTAPDFromDetail`, `dashImportTAPD`, `run-id-copy`, `data-export-logs`, `从这里重跑`, `重新触发`, `data-retrigger-issue`, `data-rerun-from-here`, `canRetriggerIssue`, `openRerunFromNode`, `executionContext?.issueId`, `run?.status==='succeeded'`, `/api/issues/${encodeURIComponent(issueId)}/requirement`, `inferSOPLane`, `req-lane-card`, `issueLaneDots`, `.filter(l=>!l.orphan)`, `lanes.length<2`, `collapseSingleSOPLane`, `issueSOPLabel`, `actionWorkflow`, `data-workflow`, `workflowSOPLane`, `需求开发`, `saveIssueSOPS`, `/sops`, `effectiveIssueSOPBindings`, `projectSOPBindings`, `fillReqWorkflow`, `plannedSOPNodes`, `sopWorkflowId`, `sopWorkflowChoices`, `renderReqConfirm`} {
if !strings.Contains(code, want) {
t.Fatalf("app.js is missing %q", want)
}
diff --git a/webtest/tests/composer-flow.test.mjs b/webtest/tests/composer-flow.test.mjs
index 94b2c11f..8dd62e68 100644
--- a/webtest/tests/composer-flow.test.mjs
+++ b/webtest/tests/composer-flow.test.mjs
@@ -57,7 +57,7 @@ test('wizard step 1 gates actions on the description and skipping goes straight
assert.ok(!app.router.calls.some((c) => c.path.endsWith('/dispatch')));
assert.ok(!app.router.calls.some((c) => c.path === '/api/chat-clarify'));
assert.equal($('#requirementModal').classList.contains('open'), false);
- assert.match($('#toastContainer').textContent, /未经澄清,不会立刻启动 SOP/);
+ assert.match($('#toastContainer').textContent, /可在详情里触发 SOP/);
});
test('wizard clarifies one question at a time, auto-submits the last answer, and dispatches a ready requirement', async (t) => {
@@ -110,7 +110,7 @@ test('wizard clarifies one question at a time, auto-submits the last answer, and
assert.equal(second.body.message, 'Which users?:Employees\nWhich checks?:Unit');
assert.equal(second.body.sessionId, 'clarify-1');
assert.match(panel.textContent, /已问清,可以创建/);
- assert.match(panel.textContent, /查看完整度详情/);
+ assert.doesNotMatch(panel.textContent, /查看完整度详情|准入线/);
assert.match($('#reqAnswerHistory').textContent, /你的回答.*Which users.*Employees/s);
assert.equal($('#reqGoCreate').textContent.trim(), '下一步:确认创建');
@@ -133,7 +133,7 @@ test('wizard clarifies one question at a time, auto-submits the last answer, and
await settle(6);
const create = app.router.calls.find((c) => c.path === '/api/issues');
assert.equal(create.body.title, 'Audit log');
- assert.equal(create.body.clarification.passed, true);
+ assert.equal(create.body.clarification.status, 'ready');
assert.ok(app.router.calls.some((c) => c.path === '/api/issues/issue-ready/dispatch'));
assert.ok(app.evaluate(`state.data.issues.some(issue=>issue.id==='issue-ready')`));
});
@@ -167,7 +167,7 @@ test('wizard creates a not-ready requirement without dispatching and handles TAP
const partial = app.router.calls.filter((c) => c.path === '/api/issues').at(-1);
assert.equal(partial.body.title, 'Complex');
assert.equal(partial.body.clarification.status, 'in_progress');
- assert.equal(partial.body.clarification.passed, false);
+ assert.equal(partial.body.clarification.passed, undefined);
assert.ok(!app.router.calls.some((c) => c.path.endsWith('/dispatch')));
assert.match($('#toastContainer').textContent, /澄清尚未完成/);
diff --git a/webtest/tests/issue-drawer-actions.test.mjs b/webtest/tests/issue-drawer-actions.test.mjs
index 27aa0ee7..216f9a46 100644
--- a/webtest/tests/issue-drawer-actions.test.mjs
+++ b/webtest/tests/issue-drawer-actions.test.mjs
@@ -9,15 +9,13 @@ test('drawer clarification, activity, delivery, and operation helpers render mea
const issue={...state.data.issues[0],source:'tapd',status:'backlog',priority:'high',
externalRef:{externalId:'T-1',externalUrl:'https://tapd.example/T-1'},
repositoryIds:['repo-1'],baseBranch:'feature/chart',
- clarification:{status:'in_progress',score:65,dimensions:{goal:80,scope:55},
- missing:['scope'],questions:[
+ clarification:{status:'in_progress',questions:[
{question:'Browser?',options:['Chrome','Safari'],multiSelect:false},
{question:'Checks?',options:['Unit','E2E'],multiSelect:true}],
history:[
{role:'assistant',content:JSON.stringify({questions:[{question:'Browser?'}]})},
{role:'user',content:'Safari'}]}};
- const project={...state.data.projects[0],clarificationPolicy:{threshold:75,dimensions:[
- {id:'goal',name:'目标'},{id:'scope',name:'范围'}]}};
+ const project={...state.data.projects[0]};
state.data.projects=[project];
state.issueDetailData={issue,comments:[
{authorType:'agent',body:'Automated note',createdAt:'2026-01-01T01:02:03Z'}],
@@ -40,7 +38,7 @@ test('drawer clarification, activity, delivery, and operation helpers render mea
visible:clarifyVisibleSummary(protocol),
hidden:clarifyThoughtShouldHide(protocol),
recovered:recoverClarifyView({status:'in_progress',summary:protocol,questions:[]}),
- score:clarifyScoreHTML(issue,project),
+ pane:clarifyPane(issue,project),
overview:clarificationOverviewCard(issue),
operations:operationsPane({...issue,createdAt:'2026-01-01',operations:[
{at:'2026-01-03',action:'update',actor:'Alice',detail:'changed title'}]}),
@@ -49,8 +47,6 @@ test('drawer clarification, activity, delivery, and operation helpers render mea
{id:'a1',nodeId:'n1',name:'Report',path:'report.md',attempt:2,size:2048,sha256:'abcdef123456'}]}}),
delivery:deliveryPane(issue,state.issueDetailData),
acceptance:acceptancePane(issue,state.issueDetailData),
- dimensions:issueClarifyDimensions({...issue,source:'gongfeng'},project).map(x=>x.id),
- levels:[clarifyScoreLevel(90),clarifyScoreLevel(70),clarifyScoreLevel(20)],
labels:[activityEventLabel('node.failed'),activityEventLabel('run.custom'),issueOperationLabel('reopen')],
badTime:formatActivityTime('not-a-date')
};
@@ -64,8 +60,8 @@ test('drawer clarification, activity, delivery, and operation helpers render mea
assert.equal(result.visible, 'prefix');
assert.equal(result.hidden, true);
assert.equal(result.recovered.questions[0].question, 'OS?');
- assert.match(result.score, /65/);
- assert.match(result.score, /范围/);
+ assert.doesNotMatch(result.pane, /信息完整度|准入线|clarify-score/);
+ assert.match(result.pane, /只围绕这张单本身/);
assert.match(result.overview, /继续/);
assert.match(result.operations, /编辑需求|changed title/);
assert.match(result.activity, /Automated note/);
@@ -73,8 +69,6 @@ test('drawer clarification, activity, delivery, and operation helpers render mea
assert.match(result.artifacts, /Report/);
assert.match(result.delivery, /feature\/chart/);
assert.match(result.acceptance, /门禁失败/);
- assert.deepEqual(result.dimensions, ['phenomenon','impact','expected','acceptance','constraints']);
- assert.deepEqual(result.levels, ['good','fair','weak']);
assert.deepEqual(result.labels, ['节点失败','运行 · custom','重新打开']);
assert.equal(result.badTime, '—');
});
@@ -90,7 +84,7 @@ test('drawer actions write back clarification and resync TAPD with API payloads'
app.router.post('/api/issues/issue-1/clarification', written);
app.router.post('/api/issues/issue-1/resync-tapd', synced);
app.router.post('/api/issues/issue-1/chat-clarify', {
- issue: { ...written, clarification: { status: 'ready', score: 88, summary: 'Clarified', writeBackStatus: 'succeeded' } },
+ issue: { ...written, clarification: { status: 'ready', summary: 'Clarified', writeBackStatus: 'succeeded' } },
ready: true
});
app.router.get('/api/issues/issue-1/chat-clarify', {}, 404);
diff --git a/webtest/tests/issue-drawer-detail.test.mjs b/webtest/tests/issue-drawer-detail.test.mjs
index 9c0dc8c4..34068a4b 100644
--- a/webtest/tests/issue-drawer-detail.test.mjs
+++ b/webtest/tests/issue-drawer-detail.test.mjs
@@ -10,7 +10,7 @@ test('issue drawer loads every tab and preserves clarification answers', async (
source: 'tapd', externalId: 'TAPD-42',
externalRef: { externalUrl: 'https://tapd.example/42' },
clarification: {
- status: 'questions', score: 58, summary: 'Needs browser details', missing: ['browser'],
+ status: 'questions', summary: 'Needs browser details',
dimensions: { goal: 80, scope: 60, acceptance: 40 },
questions: [
{ question: 'Target browser?', options: ['Chrome', 'Firefox'], multiSelect: false },
diff --git a/webtest/tests/issue-model.test.mjs b/webtest/tests/issue-model.test.mjs
index f13e57a4..1b746698 100644
--- a/webtest/tests/issue-model.test.mjs
+++ b/webtest/tests/issue-model.test.mjs
@@ -87,7 +87,7 @@ test('issue model derives lanes, health, stages, outcomes, and action markup', a
assert.deepEqual(result.chips, ['需要介入','修复','未指定 · +1']);
const edge = structuredClone(app.evaluate(`(() => {
const base={id:'edge',projectId:'p1',title:'Edge',source:'local',kind:'requirement',
- status:'backlog',workflowId:'wf-product',clarification:{status:'ready',passed:true,score:90}};
+ status:'backlog',workflowId:'wf-product',clarification:{status:'ready'}};
state.data.issues=[base];state.data.tasks=[];state.data.runs=[];
const stages=[];
stages.push(issueCurrentStage({...base,status:'closed',closeSource:'manual'}).label);
@@ -101,23 +101,29 @@ test('issue model derives lanes, health, stages, outcomes, and action markup', a
state.data.runs=[{id:'cancel',workflowId:'wf-product',status:'cancelled',
executionContext:{issueId:'edge'},nodes:{p1:{status:'cancelled'}}}];
stages.push(issueCurrentStage(base).label);
+ state.data.tasks=[];state.data.runs=[];
+ const asked={...base,clarification:{status:'in_progress',questions:[{id:'q1',question:'Q?',options:['A','B']}]}};
+ stages.push(issueCurrentStage(asked).label,issueCurrentStage(asked).key,issueRunHealth(asked));
+ stages.push(issueCurrentStage({...base,clarification:{status:'in_progress',questions:[]}}).label);
+ const askedTrigger=triggerSOPButton(asked);
const actionKinds=[
issueActionButtons({...base,status:'closed',closeSource:'manual'}),
issueActionButtons({...base,clarification:{status:'analyzing'}}),
- issueActionButtons({...base,clarification:{status:'needs_user',score:20,gated:true}})
+ issueActionButtons({...base,clarification:{status:'needs_user',gated:true}})
];
const triggers=[
triggerSOPButton({...base,clarification:{status:'ready',writeBackStatus:'pending'},source:'tapd',
externalRef:{externalId:'T-1'}}),
- triggerSOPButton({...base,clarification:{status:'needs_user',score:20,gated:true}})
+ triggerSOPButton({...base,clarification:{status:'needs_user',gated:true}})
];
- return {stages,actionKinds,triggers,externals:[
+ return {stages,actionKinds,triggers,askedTrigger,externals:[
issueExternalState({externalRef:{externalState:' 已关闭 '}}),
issueExternallyDone({externalRef:{externalState:'已完成'}}),
issueInPlanning({externalRef:{externalState:'planning'}})
]};
})()`));
- assert.deepEqual(edge.stages, ['已关闭','已完成','澄清完成 · 90 分','排队中','交付闭环','已取消 · 定义']);
+ assert.deepEqual(edge.stages, ['已关闭','已完成','澄清已完成','排队中','交付闭环','已取消 · 定义','待澄清','clarifying','not_started','等待执行']);
+ assert.match(edge.askedTrigger, /data-dispatch-issue/);
assert.match(edge.actionKinds.join(' '), /更多操作/);
assert.match(edge.triggers[0], /确认结论/);
assert.match(edge.triggers[1], /触发/);
diff --git a/webtest/tests/issues-list.test.mjs b/webtest/tests/issues-list.test.mjs
index 374fb7cc..4a3e851b 100644
--- a/webtest/tests/issues-list.test.mjs
+++ b/webtest/tests/issues-list.test.mjs
@@ -11,7 +11,7 @@ test('issue list helpers filter, format, parse repositories, and persist edits',
app.router.put('/api/issues/issue-1/sops', { ...saved, sopBindings: [{ workflowId: 'flow-1', order: 1 }] });
app.router.post('/api/issues/import-tapd', {
id: 'tapd-new', projectId: 'project-1', title: 'Imported TAPD', source: 'tapd',
- status: 'backlog', repositoryIds: ['repo-1'], clarification: { status: 'ready', score: 90 }
+ status: 'backlog', repositoryIds: ['repo-1'], clarification: { status: 'ready' }
});
const result = structuredClone(await app.evaluate(`(async () => {
state.data.projects[0].key='ATL';
diff --git a/webtest/tests/module-logic.test.mjs b/webtest/tests/module-logic.test.mjs
index 04755d02..5af26db1 100644
--- a/webtest/tests/module-logic.test.mjs
+++ b/webtest/tests/module-logic.test.mjs
@@ -8,7 +8,7 @@ test('issue drawer panes render clarification, SOP, delivery, and activity data'
const rendered = app.evaluate(`
(() => {
const issue={...state.data.issues[0], status:'completed', source:'tapd', externalId:'TAPD-9',
- clarification:{status:'completed',score:86,summary:'Clear objective',questions:[
+ clarification:{status:'completed',summary:'Clear objective',questions:[
{id:'q1',question:'Which browser?',options:['Chrome','Firefox'],required:true}
],history:[{role:'assistant',content:'Please clarify'},{role:'user',content:'Chrome'}]},
operations:[{action:'closed',createdAt:'2026-10-21T10:00:00Z',userName:'Tester'}]};
@@ -19,7 +19,7 @@ test('issue drawer panes render clarification, SOP, delivery, and activity data'
state.issueDetailData=data;
return [
clarificationOverviewCard(issue), clarifyQuestionCardsHTML(issue.clarification.questions,{}),
- clarifyScoreHTML(issue,project), clarifyHistoryHTML(issue.clarification),
+ clarifyHistoryHTML(issue.clarification),
clarifyPane(issue,project), sopPane(issue,data), artifactsPane(data), deliveryPane(issue,data),
acceptancePane(issue,data), operationsPane(issue), activityPane(issue,data),
issueProgressActionsHTML(issue,run,{includeIssueActions:true})