cowork-flow 1.7.2 → 1.8.0

package/template/.opencode/cowork-flow/plugin-core.js

@@ -574,8 +574,14 @@ function parseDecisionAnchor(text) {
     if (section === "目标") {
       if (line) goalLines.push(line)
     } else if (section === "验收标准") {
-      const match = raw.match(/^\s*-\s*\[[ xX]?\]\s*(AC-[A-Za-z0-9-]+)\s*[:：]\s*(.+?)\s*$/)
-      if (match) result.acceptanceCriteria.push({ id: match[1], text: match[2] })
+      const match = raw.match(/^\s*-\s*(?:\[([ xX])\]?\s*)?(AC-[A-Za-z0-9-]+)\s*[:：]\s*(.+?)\s*$/)
+      if (match) {
+        result.acceptanceCriteria.push({
+          id: match[2],
+          text: match[3],
+          checked: match[1] === 'x' || match[1] === 'X',
+        })
+      }
     } else if (section === "被拒方案") {
       const match = raw.match(/^\s*-\s*\*\*(.+?)\*\*/)
       if (match) result.rejectedOptions.push(match[1].trim())
@@ -836,6 +842,36 @@ function withStageFacts(block, root, taskPath, status, readonly = false) {
   return parts.length > 0 ? `${parts.join("\n\n")}\n\n${block}` : block
 }
 
+// Evidence coverage for the anchor block: one read of the task's
+// evidence.jsonl, tolerating noise exactly like the python line. Returns
+// null when the file is absent so the coverage line degrades silently.
+function readEvidenceCoverage(root, taskPath) {
+  let text = ''
+  try {
+    text = readFileSync(resolve(root, taskPath, 'evidence.jsonl'), 'utf8')
+  } catch {
+    return null
+  }
+  const covered = new Set()
+  for (const raw of text.split('\n')) {
+    const line = raw.trim()
+    if (!line) continue
+    let record
+    try {
+      record = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (!record || typeof record !== 'object' || Array.isArray(record)) continue
+    const ac = typeof record.ac === 'string' ? record.ac.trim() : ''
+    const ref = typeof record.ref === 'string' ? record.ref.trim() : ''
+    if (ac && ref && ['test', 'command', 'manual'].includes(record.kind)) {
+      covered.add(ac)
+    }
+  }
+  return covered
+}
+
 function decisionAnchorBlock(root, taskPath, status) {
   if (!taskPath) {
     return null
@@ -868,6 +904,17 @@ function decisionAnchorBlock(root, taskPath, status) {
     lines.push(
       `Acceptance: ${parsed.acceptanceCriteria.slice(0, 8).map((item) => `${item.id} ${item.text.slice(0, 80)}`).join("; ")}`
     )
+    const covered = readEvidenceCoverage(root, taskPath)
+    if (covered) {
+      const total = parsed.acceptanceCriteria.length
+      const missing = parsed.acceptanceCriteria
+        .map((item) => item.id)
+        .filter((id) => !covered.has(id))
+      const detail = missing.length
+        ? ` missing=${missing.slice(0, 5).join(',')}`
+        : ''
+      lines.push(`AC evidence: ${total - missing.length}/${total}${detail}`)
+    }
   }
   if (parsed.rejectedOptions.length > 0) {
     lines.push(`Rejected: ${parsed.rejectedOptions.slice(0, 6).join("; ")}`)
@@ -1073,5 +1120,6 @@ export {
   runEditSpecCheck,
   contractFingerprint,
   stableStringify,
-  stageContractBlock
+  stageContractBlock,
+  decisionAnchorBlock
 }

package/template/skills/spec-sync/SKILL.md

@@ -33,6 +33,7 @@ Keep each update concrete:
 - Show the contract or command shape.
 - Include good/bad cases when useful.
 - State tests or checks that protect the behavior.
+- When a clause is machine-checkable (可机检), add or refresh its `checks:` declaration in the same pass (main session only — never rewrite the clause text): the command must pass on a clean tree, a negative case must prove it can fail, `files` must narrow the scope, and a `spec-check` run after writing must confirm the declaration parses.
 - Update the matching `index.md` when adding a new topic.
 - Check for duplicate guidance and remove stale wording before finishing.
 

package/template/skills/task-review/SKILL.md

@@ -37,7 +37,8 @@ Read only what is needed for the current task:
 - **Scope**: every changed file is planned or justified; no unrelated cleanup sneaks in.
 - **Behavior**: acceptance criteria are satisfied through observable behavior, not implementation-shaped assertions.
 - **Tests**: test intent is explicit; tests fail for meaningful regressions, reject shallow tests such as existence/mock/snapshot-only checks, and cover boundary/error paths when relevant.
-- **User specs**: every applicable backend/frontend requirement is verified against the diff and marked `pass`, `finding`, or `not_applicable` with reason. Every `finding` is fixed during review; an unfixed spec violation blocks completion and is never accepted as-is or deferred to the user.
+- **Evidence coverage**: when the decision anchor declares acceptance criteria (`AC-xxx`), verify each one has an evidence record in `<task>/evidence.jsonl` — or a recorded `meta.evidenceExempt` exemption from an explicit `--allow-missing-evidence` completion. Schema and gate codes (`LIFECYCLE-AC-001/002`) are defined in `.cowork-flow/spec/contracts/evidence-completion.md`. A record must point at real proof (test, command output, or manual verification note); a record that restates the AC without evidence is a finding.
+- **User specs**: every applicable backend/frontend requirement is verified against the diff and marked `pass`, `finding`, or `not_applicable` with reason. Every `finding` is fixed during review; an unfixed spec violation blocks completion and is never accepted as-is or deferred to the user. For each requirement, also ask whether it is machine-checkable (可机检) and already declared with `checks:`; identifying checkable clauses and adding or refreshing declarations is a main-session duty (never rewrite the clause text — raise a conflict through the review instead), and a declared check must earn its place: the command passes on a clean tree, a negative case proves it can fail, `files` narrows the scope, and a `spec-check` run after declaring confirms the declaration parses. Delegated subagents do not edit specs; they report candidates up.
 - **Specs**: project specs are updated when behavior/contracts changed, or the review states why no spec update is needed.
 - **Code quality**: naming, layering, error handling, state boundaries, security-sensitive paths, and complexity are reviewed against applicable user specs.
 - **Lifecycle blockers**: state/scope blockers are fixed before acceptance; review does not invent hard blockers for natural-language specs.
@@ -61,7 +62,7 @@ Return a concise review result with:
 - `status`: `pass`, `needs_fix`, or `blocked`.
 - `findings`: severity, file, line/scope, impact, and fix.
 - `test_intent_review`: why tests prove the intended behavior or what is missing.
-- `user_spec_review`: applicable spec files, per-requirement result, and findings.
+- `user_spec_review`: applicable spec files, per-requirement result, findings, and the "clause → command" list for every `checks:` declaration added or refreshed in this review (`none` when nothing became machine-checkable).
 - `lifecycle_check_review`: lifecycle commands run, blocker status, and resolution.
 - `verification`: exact commands run from this checkout.
 - `specUpdates`: files updated or reason no update was needed.

package/template/skills/test-first/SKILL.md

@@ -39,6 +39,10 @@ If red-first is skipped, state the reason before or with the implementation summ
 
 Do not write TDD evidence objects to `check.jsonl`, do not create `tdd.jsonl`, and do not create TDD exemption records. Report the exact red/green commands in the agent response or task review narrative when useful; the workflow does not validate them as separate evidence artifacts.
 
+## Evidence records
+
+When the task's decision anchor declares acceptance criteria, a green test from a red-green cycle is the canonical completion evidence for the mapped AC: append one record to the task's `evidence.jsonl` — `{"ac": "AC-xxx", "kind": "test", "ref": "<test file>::<case>", "note": "<core assertion>", "recordedAt": "<date>", "by": "<session>"}`. This is task-level completion evidence governed by `.cowork-flow/spec/contracts/evidence-completion.md`; it is a different artifact from the forbidden `tdd.jsonl` above, and this skill still does not require or validate it — recording it as you go simply spares the completion gate a block later.
+
 ## Anti-Rationalization
 
 Do not use these excuses to skip meaningful behavior tests: