crewly 1.20.349 → 1.20.351

package/config/skills/agent/core/complete-task/SKILL.md

@@ -46,12 +46,12 @@ Mark a task as complete with a summary of the work done. If the task has an outp
 | `workItemId` | Preferred | ID of the V3 WorkItem to complete. This is the only input that selects the WorkItem |
 | `sessionName` | Yes | Your agent session name |
 | `summary` | Yes | Summary of the work completed |
-| `evidence` | Yes* | Array of evidence entries — see **Evidence contract** below. *Accepted without it this release (with a warning); required from the next release |
+| `evidence` | Yes* | Array of evidence entries — see **Evidence contract** below. *Required: refused without it (400 `evidence_required`), except a review `verdict` |
 | `absoluteTaskPath` | No | **Legacy (V1).** Still accepted so older callers keep working, but it does NOT identify a WorkItem |
 | `output` | No | Structured output object (required if task has an output schema) |
 | ~~`skipGates`~~ | **Rejected** | **Not supported.** This endpoint runs no quality gates, so there is nothing to skip. Passing it is a hard error. Use the `check-quality-gates` skill for gates. |
 
-**Any other field is an error.** The skill accepts only the fields in this table plus `verdict`/`feedback` (reviews) and `taskId`/`artifacts`/`testResults`/`structured` (verification requests). An unknown field (for example `projectPath`, `skipGates`, `force`) stops the call before anything is sent, and the error names the field. Put extra results inside `output`.
+**Any other field is an error.** The skill accepts only the fields in this table plus `verdict`/`feedback`/`checks` (reviews) and `taskId`/`artifacts`/`testResults`/`structured` (verification requests). An unknown field (for example `projectPath`, `skipGates`, `force`) stops the call before anything is sent, and the error names the field. Put extra results inside `output`.
 
 On success the skill prints **one JSON line** that always names the `workItemId`, plus the server's reply (`success`, `message`, any `warning`).
 
@@ -83,8 +83,8 @@ items for one session.
 
 If you could not finish, do **not** report done: send a `blocked` entry (or use
 `report-status --status blocked`). Malformed evidence is rejected with 400
-naming the bad entry. A completion with no evidence is accepted this release
-but the response (and stderr) carries a `warning`; next release it is a 400.
+naming the bad entry. A completion with no evidence is refused with 400
+`evidence_required` and nothing is completed (#1312).
 A review verdict (`verdict` set) needs no evidence.
 
 ## Example
@@ -154,9 +154,10 @@ JSON confirmation of task completion status. If validation fails:
 
 When the item you're completing is a review of another agent's work:
 
-- **Accept:** complete it normally with a summary.
+- **Accept:** open or re-run the worker's evidence (the item lists it numbered; `verify-output` shows it in full) and send `"verdict":"verified"` with `"checks"`: one `{"entry":<index>,"did":"<what you did and saw>","outcome":"pass"}` per entry you checked, `"entry":null` for a direct look at the work. At least one check must name a worker evidence entry when there is any. An accept without checks, or with a `"fail"` check, is refused (400 `review_unchecked` / `review_check_failed`) and nothing is accepted.
 - **Send it back:** add `"verdict":"rejected"` and `"feedback":"<what is wrong>"`. The worker gets a retry that includes your feedback. Feedback is required when you reject.
 
 ```bash
+bash execute.sh '{"workItemId":"<verify item id>","sessionName":"<you>","summary":"Export is right","verdict":"verified","checks":[{"entry":0,"did":"opened export.csv: 120 rows, header present","outcome":"pass"},{"entry":1,"did":"re-ran npm test: exit 0","outcome":"pass"}]}'
 bash execute.sh '{"workItemId":"<verify item id>","sessionName":"<you>","summary":"Header row missing","verdict":"rejected","feedback":"Add the header row and re-run the export"}'
 ```

package/config/skills/agent/core/complete-task/execute.sh

@@ -35,7 +35,7 @@ SUMMARY=$(printf '%s' "$INPUT" | jq -r '.summary // empty')
 # ignoring a field is the worst disposition: the caller believes it did
 # something, and nothing ever fails. So every field this skill does not use
 # fails loudly, with its name, before any request is sent.
-ALLOWED_FIELDS='["workItemId","absoluteTaskPath","sessionName","summary","output","evidence","verdict","feedback","taskId","artifacts","testResults","structured"]'
+ALLOWED_FIELDS='["workItemId","absoluteTaskPath","sessionName","summary","output","evidence","verdict","feedback","checks","taskId","artifacts","testResults","structured"]'
 SKIP_GATES=$(printf '%s' "$INPUT" | jq -r 'has("skipGates")')
 if [ "$SKIP_GATES" = "true" ]; then
   error_exit "skipGates is not supported by complete-task and never was — it was accepted and silently discarded. POST /task-pool/complete runs no quality gates, so there is nothing here to skip. Quality gates live behind the 'check-quality-gates' skill (POST /quality-gates/check); run or skip them there. Remove skipGates from this call."
@@ -67,6 +67,13 @@ fi
 if [ "$VERDICT" = "rejected" ] && [ -z "$FEEDBACK" ]; then
   error_exit "verdict \"rejected\" needs feedback: say what is wrong so the retry can fix it"
 fi
+# Accepting a review records what you checked, per worker evidence entry
+# (#1314): [{"entry":<index or null>,"did":"<what you did and saw>","outcome":"pass"|"fail"}].
+# The server refuses an accept without it; this only catches a non-array.
+CHECKS_JSON=$(printf '%s' "$INPUT" | jq -c '.checks // empty')
+if [ -n "$CHECKS_JSON" ] && [ "$(printf '%s' "$CHECKS_JSON" | jq -r 'type')" != "array" ]; then
+  error_exit "checks must be a JSON array, e.g. [{\"entry\":0,\"did\":\"opened report.md: covers all 3 asks\",\"outcome\":\"pass\"}]"
+fi
 require_param "sessionName" "$SESSION_NAME"
 require_param "summary" "$SUMMARY"
 
@@ -167,6 +174,7 @@ BODY=$(jq -n \
   --arg verdict "$VERDICT" \
   --arg feedback "$FEEDBACK" \
   --argjson evidence "${EVIDENCE_JSON:-null}" \
+  --argjson checks "${CHECKS_JSON:-null}" \
   '{
     agentId: $agentId,
     result: ({summary: $summary}
@@ -175,7 +183,8 @@ BODY=$(jq -n \
                  else {} end)
               + (if $verdict != "" then {verdict: $verdict} else {} end)
               + (if $feedback != "" then {feedback: $feedback} else {} end)
-              + (if $evidence != null then {evidence: $evidence} else {} end))
+              + (if $evidence != null then {evidence: $evidence} else {} end)
+              + (if $checks != null then {checks: $checks} else {} end))
   }')
 
 COMPLETE_RESPONSE=$(api_call POST "/task-pool/complete/${WORK_ITEM_ID}" "$BODY")
@@ -191,8 +200,8 @@ if [ -z "$RESULT_LINE" ]; then
     '{success: true, workItemId: $id, message: ("WorkItem " + $id + " completion was accepted; the server reply was not JSON."), raw: $raw}')
 fi
 printf '%s\n' "$RESULT_LINE"
-# Warn-mode rollout (#873): the server accepts a completion without evidence
-# for one release but says so. Repeat it on stderr so it is not missed.
+# With CREWLY_EVIDENCE_MODE=warn the server accepts a completion without
+# evidence but says so (#873, #1312). Repeat it on stderr so it is not missed.
 EVIDENCE_WARNING=$(printf '%s' "$COMPLETE_RESPONSE" | jq -r '.warning // empty' 2>/dev/null || true)
 if [ -n "$EVIDENCE_WARNING" ]; then
   jq -n --arg w "$EVIDENCE_WARNING" '{warning: $w}' >&2

package/config/skills/agent/core/complete-task/execute.test.sh

@@ -224,6 +224,13 @@ assert_not_contains "no request sent without feedback" "/task-pool/complete" "$R
 run_skill '{"workItemId":"wi-verify","sessionName":"tl-1","summary":"x","verdict":"maybe"}'
 assert_contains "unknown verdict is refused" "verdict must be" "$OUT"
 
+run_skill '{"workItemId":"wi-verify","sessionName":"tl-1","summary":"ok","verdict":"verified","checks":[{"entry":0,"did":"opened it","outcome":"pass"}]}'
+CHECKS_BODY="$(printf '%s' "$BODIES" | grep 'agentId' | head -1 || true)"
+assert_contains "checks land in result (#1314)" '"did": "opened it"' "$CHECKS_BODY"
+
+run_skill '{"workItemId":"wi-verify","sessionName":"tl-1","summary":"ok","verdict":"verified","checks":"looked at it"}'
+assert_contains "non-array checks are refused" "checks must be a JSON array" "$OUT"
+
 run_skill '{"workItemId":"wi-plain","sessionName":"dev-1","summary":"done"}'
 PLAIN_BODY="$(printf '%s' "$BODIES" | grep 'agentId' | head -1 || true)"
 assert_not_contains "no verdict key when none given" '"verdict"' "$PLAIN_BODY"

package/config/skills/agent/core/report-status/SKILL.md

@@ -74,9 +74,9 @@ For a bug fix, the failing "before" run belongs in the evidence too: put it in t
 
 The server rejects (400) a missing artifact, a non-zero exit code, or a
 malformed entry; the skill then prints `{"warning":"… completing the WorkItem
-FAILED …","error":…}` with the reason. Without any evidence, `done` is accepted
-**this release** with a `warning` on stderr; from the next release it is
-refused. If you could not finish, report `--status blocked` (or `done` with
+FAILED …","error":…}` with the reason. Without any evidence, `done` is
+**refused** (400 `evidence_required`) and the WorkItem stays open; the skill
+prints a `next` line with the flags to add. If you could not finish, report `--status blocked` (or `done` with
 `--blocked-step/--blocked-reason`), never `done`.
 
 ## This skill COMPLETES a WorkItem, not just reports

package/config/skills/agent/core/report-status/execute.sh

@@ -53,7 +53,7 @@ Evidence (status done — #873: "done" needs evidence):
   --blocked-reason <why>   ... and why. The WorkItem is recorded as BLOCKED, not done.
   --evidence <json>        Raw evidence array, e.g. '[{"type":"artifact","path":"/abs/f"}]'
   A non-zero --exit-code or a missing artifact is rejected by the server. Without
-  any evidence, done is accepted this release with a warning; next release it is refused.
+  any evidence, done is refused and the WorkItem stays open (#1312).
   --help     | -h   Show this help
 EOF_USAGE
 }
@@ -385,8 +385,8 @@ if [ "$STATUS" = "done" ]; then
     # `agentId is required` + `summary required in body.result`,
     # forcing every worker into a direct-curl workaround.
     #
-    # #873: the evidence block goes in result.evidence. Omitted when empty
-    # (the server then warns this release, refuses the next).
+    # #873: the evidence block goes in result.evidence. Omitted when empty;
+    # the server then refuses a deliverable's completion (#1312).
     COMPLETE_BODY=$(jq -n \
       --arg agentId "$SESSION_NAME" \
       --arg summary "$SUMMARY" \
@@ -410,8 +410,12 @@ if [ "$STATUS" = "done" ]; then
           '{completedWorkItem: $id, resolvedBy: $how} + (if $w != "" then {warning: $w} else {} end)' >&2
       fi
     else
-      jq -n --arg id "$TARGET_WI_ID" --arg err "$COMPLETE_RESULT" \
-        '{warning: "status reported, but completing the WorkItem FAILED — it is still open", workItemId: $id, error: $err}' >&2
+      NEXT_STEP=""
+      case "$COMPLETE_RESULT" in
+        *evidence_required*) NEXT_STEP="Run report-status --status done again with evidence: --artifact <file or https URL> (repeatable) and/or --command '<cmd>' --exit-code N; if you could not finish, --blocked-step '<step>' --blocked-reason '<why>'." ;;
+      esac
+      jq -n --arg id "$TARGET_WI_ID" --arg err "$COMPLETE_RESULT" --arg next "$NEXT_STEP" \
+        '{warning: "status reported, but completing the WorkItem FAILED — it is still open", workItemId: $id, error: $err} + (if $next != "" then {next: $next} else {} end)' >&2
     fi
   fi
 fi

package/config/skills/agent/core/trace-read/SKILL.md

@@ -27,6 +27,8 @@ triggers:
   - how did the run go
   - what happened to my work
   - why was it stuck
+  - where is it now
+  - who has it
   - stalls
   - retro
   - autonomy
@@ -87,6 +89,18 @@ You get, in at most `--max-chars` (default 4000):
   counted).
 - **Links** — the dashboard page with its Timeline tab, and the API.
 
+## Where a request is now
+
+```bash
+bash execute.sh --where TKT-12          # or the request id
+```
+
+Who holds the owner's request right now, what they are doing (working,
+queued, blocked, reviewing, waiting on another agent, waiting on the owner)
+and for how long. It follows plain-message hand-offs too: if Ella passed it
+to Pia and Pia to Dex, you see all three and that Dex has it. Use this when
+the owner asks "how is X going" or "is it forgotten", before guessing.
+
 ## Recent runs
 
 ```bash

package/config/skills/agent/core/trace-read/execute.sh

@@ -10,6 +10,7 @@
 #   bash execute.sh --trace tr-20261003-ab12cd34
 #   bash execute.sh --work-item <id> | --ticket CE-7 | --ticket TKT-12 | --request <id> | --experiment EXP-3
 #   bash execute.sh --since 2026-10-01T00:00:00Z [--limit 10]      # recent runs, one line each
+#   bash execute.sh --where TKT-12 | --where <request id>             # who holds it NOW, doing what, since when
 #   Options: [--max-chars 4000] [--stall-minutes 30] [--json]
 # =============================================================================
 set -euo pipefail
@@ -25,6 +26,7 @@ Usage:
   bash execute.sh --request ID                     The run of a Request
   bash execute.sh --experiment EXP-3               The run of an experiment card
   bash execute.sh --since ISO [--limit 10]         Runs active since then, one line each, newest first (at most 100)
+  bash execute.sh --where TKT-12 | --where ID      Where an owner request is NOW: who holds it, doing what, for how long
 Options:
   --max-chars N       Size bound of the output (default 4000, 600..16000)
   --stall-minutes N   A gap with no progress longer than this is a stall (default 30)
@@ -32,10 +34,11 @@ Options:
 EOF_USAGE
 }
 
-TRACE=""; WORK_ITEM=""; TICKET=""; REQUEST=""; EXPERIMENT=""; SINCE=""; LIMIT="10"; MAX_CHARS="4000"; STALL=""; JSON_OUT="0"
+WHERE=""; TRACE=""; WORK_ITEM=""; TICKET=""; REQUEST=""; EXPERIMENT=""; SINCE=""; LIMIT="10"; MAX_CHARS="4000"; STALL=""; JSON_OUT="0"
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    --where)          [ $# -ge 2 ] || error_exit "--where requires a request id or TKT-n"; WHERE="$2"; shift 2 ;;
     --trace|-t)       [ $# -ge 2 ] || error_exit "--trace requires a value"; TRACE="$2"; shift 2 ;;
     --work-item|-w)   [ $# -ge 2 ] || error_exit "--work-item requires a value"; WORK_ITEM="$2"; shift 2 ;;
     --ticket)         [ $# -ge 2 ] || error_exit "--ticket requires a value"; TICKET="$2"; shift 2 ;;
@@ -65,9 +68,29 @@ enc() { jq -rn --arg v "$1" '$v|@uri'; }
 STALL_QS=""
 [ -n "$STALL" ] && STALL_QS="&stallMinutes=$(enc "$STALL")"
 
+# --- Where a request is now (backed by GET /api/requests/:id/whereabouts) ---
+if [ -n "$WHERE" ]; then
+  if ! RESP=$(api_call_full GET "/requests/$(enc "$WHERE")/whereabouts"); then
+    error_exit "No owner request $WHERE (pass a request id or TKT-n)"
+  fi
+  if [ "$JSON_OUT" = "1" ]; then
+    printf '%s' "$RESP" | jq -c '{success: true} + .data'
+    exit 0
+  fi
+  printf '%s' "$RESP" | jq -r --argjson max "$MAX_CHARS" '
+    def dur: (. / 60000 | floor) as $m
+      | if $m < 60 then "\($m)m" elif $m < 2880 then "\($m / 60 | floor)h \($m % 60)m" else "\($m / 1440 | floor)d \(($m % 1440) / 60 | floor)h" end;
+    .data as $d
+    | ([ "\(if $d.ticketNumber then "TKT-\($d.ticketNumber) · " else "" end)\($d.title[0:100]) · \($d.status)", $d.summary ]
+       + [ $d.holders[] | "- \(.session): \(.state | gsub("_"; " ")) for \(.forMs | dur) (since \(.since[0:16] | sub("T"; " ")))\(if .workItemId then " · \(.workItemId)" else "" end)\(if .from then " · from \(.from)" else "" end)\(if .blockedReason then " · blocked: \(.blockedReason[0:120])" else "" end)\(if .what then " · \(.what[0:100])" else "" end)" ]
+       | join("\n")) as $text
+    | if ($text | length) > $max then $text[0:($max - 1)] + "…" else $text end'
+  exit 0
+fi
+
 # --- Recent runs -------------------------------------------------------------
 if [ -z "$TRACE$WORK_ITEM$TICKET$REQUEST$EXPERIMENT" ]; then
-  [ -n "$SINCE" ] || { print_usage >&2; error_exit "Pass one of --trace, --work-item, --ticket, --request, --experiment or --since"; }
+  [ -n "$SINCE" ] || { print_usage >&2; error_exit "Pass one of --where, --trace, --work-item, --ticket, --request, --experiment or --since"; }
   if ! RESP=$(api_call_full GET "/traces?since=$(enc "$SINCE")&limit=$(enc "$LIMIT")${STALL_QS}"); then
     error_exit "Could not list traces since $SINCE"
   fi

package/config/skills/orchestrator/complete-task/SKILL.md

@@ -38,7 +38,7 @@ bash config/skills/orchestrator/complete-task/execute.sh '{"workItemId":"wi-123"
 |-----------|----------|-------------|
 | `workItemId` (alias `taskId`) | Yes | The WorkItem to complete |
 | `summary` (alias `result`) | Yes | What was produced |
-| `evidence` | Yes* | Evidence array (#873): `{"type":"artifact","path":…}` (must exist, or an https URL), `{"type":"command","command":…,"exitCode":0,"outputTail":…}`, or `{"type":"blocked","step":…,"reason":…}` (records the item as blocked, not done). *Accepted without it this release with a `warning`; required from the next |
+| `evidence` | Yes* | Evidence array (#873): `{"type":"artifact","path":…}` (must exist, or an https URL), `{"type":"command","command":…,"exitCode":0,"outputTail":…}`, or `{"type":"blocked","step":…,"reason":…}` (records the item as blocked, not done). *Required for delegate/project_task/review items (400 `evidence_required` without it); bookkeeping types (triage, replans, retros) may omit it |
 | `output` | No | Structured output stored on the WorkItem before completion |
 | `agentId` / `sessionName` | No | Who completed it (defaults to `crewly-orc`) |
 

package/config/skills/orchestrator/complete-task/execute.sh

@@ -13,8 +13,9 @@
 #
 # `evidence` (#873) is sent as result.evidence. The server checks it: missing
 # artifacts and non-zero exit codes are refused, a `blocked` entry records the
-# item as blocked instead of done, and no evidence at all is accepted this
-# release with a `warning` (refused from the next).
+# item as blocked instead of done, and no evidence at all is refused for a
+# deliverable (delegate, project_task, review without a verdict). Bookkeeping
+# types (triage, replans, retros) complete without it (#1312).
 #
 # Backwards-compat: a `taskId` field is accepted as alias for `workItemId`.
 

package/config/skills/orchestrator/render-verdict/SKILL.md

@@ -45,7 +45,7 @@ orchestrator) and the backend recognizes the caller correctly.
 
 ```bash
 CREWLY_SESSION_NAME=crewly-orc bash config/skills/orchestrator/render-verdict/execute.sh \
-  '{"workItemId":"abc-123","verdict":"verified","comment":"Meets the acceptance criteria"}'
+  '{"workItemId":"abc-123","verdict":"verified","comment":"Meets the acceptance criteria","checks":[{"entry":0,"did":"opened report.md: covers the 3 asks","outcome":"pass"}]}'
 ```
 
 ## Parameters
@@ -53,6 +53,7 @@ CREWLY_SESSION_NAME=crewly-orc bash config/skills/orchestrator/render-verdict/ex
 - `workItemId` (required, alias `taskId`) — the `done_by_worker` WorkItem to verdict.
 - `verdict` (required) — `"verified"` or `"rejected"`.
 - `comment` (optional) — reviewer's note; required in practice for a rejection so the worker knows what to fix.
+- `checks` (required for `verified`, #1314) — what you checked: `[{"entry":<index in the item's output.evidence, or null for a direct look>,"did":"<what you did and saw>","outcome":"pass"|"fail"}]`. At least one must name an evidence entry when the worker sent any. Without it (or with a `fail`) the server returns 400 `review_unchecked` / `review_check_failed` and nothing is verified.
 
 ## Output
 

package/config/skills/orchestrator/render-verdict/execute.sh

@@ -38,10 +38,14 @@ if [ "$VERDICT" != "verified" ] && [ "$VERDICT" != "rejected" ]; then
   error_exit "verdict must be \"verified\" or \"rejected\" (got: \"${VERDICT}\")"
 fi
 
-if [ -n "$COMMENT" ]; then
-  BODY=$(jq -n --arg verdict "$VERDICT" --arg comment "$COMMENT" '{verdict: $verdict, comment: $comment}')
-else
-  BODY=$(jq -n --arg verdict "$VERDICT" '{verdict: $verdict}')
+# An accept records what you checked (#1314): the server refuses
+# "verified" without checks.
+CHECKS=$(printf '%s' "$INPUT" | jq -c '.checks // empty')
+if [ -n "$CHECKS" ] && [ "$(printf '%s' "$CHECKS" | jq -r 'type')" != "array" ]; then
+  error_exit "checks must be a JSON array, e.g. [{\"entry\":0,\"did\":\"opened report.md: covers the 3 asks\",\"outcome\":\"pass\"}]"
 fi
 
+BODY=$(jq -n --arg verdict "$VERDICT" --arg comment "$COMMENT" --argjson checks "${CHECKS:-null}" \
+  '{verdict: $verdict} + (if $comment != "" then {comment: $comment} else {} end) + (if $checks != null then {checks: $checks} else {} end)')
+
 api_call POST "/task-pool/items/${WORK_ITEM_ID}/verdict" "$BODY"

package/config/skills/team-leader/verify-output/SKILL.md

@@ -40,10 +40,13 @@ WorkItem: artifacts that exist, commands with exit codes, blocked steps) before
 running any check, and returns it as the first field of the verdict.
 
 - `evidenceWarning` is set when the item was marked done **without evidence**
-  (accepted only while the server is in evidence warn mode) — do not verify it
+  (possible only with `CREWLY_EVIDENCE_MODE=warn` or before #1312) — do not verify it
   on its summary alone: check the work directly or send it back asking for
   evidence. It is also set when the worker reported `blocked` steps.
 - The warning, when present, leads `feedback`.
+- Each evidence entry is listed with its index. When you accept, record what
+  you did to each one you checked (#1314): open the artifact, re-run the
+  command, look at the page. An accept without that record is refused.
 
 ## When to Use
 
@@ -162,8 +165,10 @@ requiresReview: true → TL must manually evaluate these steps
 ### Accept finished work; never cancel it
 
 When the work is done and checks pass, ACCEPT it: complete the item (for a
-"Verify: ..." item, `complete-task` with `"verdict":"verified"` and your
-evidence). Do not cancel a WorkItem that was done or verified, even with a
+"Verify: ..." item, `complete-task` with `"verdict":"verified"` and
+`"checks":[{"entry":<evidence index, or null for a direct look>,"did":"<what you did and saw>","outcome":"pass"}]`,
+at least one naming a worker evidence entry when there is any). A failed
+check cannot be accepted: send it back with `"verdict":"rejected"`. Do not cancel a WorkItem that was done or verified, even with a
 "verified" note: a cancel is for work that should not happen, and a project
 ticket whose WorkItem is cancelled can go back to the queue so the same work
 is picked up twice. Cancel only work that is NOT done.

package/config/skills/team-leader/verify-output/execute.sh

@@ -39,8 +39,8 @@ WI_OUTPUT_RAW=$(echo "$WI_DATA" | jq -c '.data.output // empty' 2>/dev/null || t
 # Evidence first (#873). The worker's completion carries an evidence block
 # (artifacts that exist, commands with exit codes, or blocked steps), stored
 # at output.evidence. Read it before anything else, and flag an item that was
-# marked done WITHOUT evidence — accepted only because the server is in warn
-# mode this release — so it is not verified on its summary alone.
+# marked done WITHOUT evidence — possible only with CREWLY_EVIDENCE_MODE=warn
+# or on an item completed before #1312 — so it is not verified on its summary alone.
 WI_FOUND=$(echo "$WI_DATA" | jq -r 'if (.data // null) != null then "yes" else "no" end' 2>/dev/null || echo "no")
 WI_EVIDENCE=$(echo "$WI_DATA" | jq -c 'if (.data.output.evidence | type) == "array" then .data.output.evidence else [] end' 2>/dev/null || echo '[]')
 EVIDENCE_WARNING=""
@@ -359,7 +359,8 @@ jq -n \
   --arg workerId "$WORKER_ID" \
   --arg templateId "$TEMPLATE_ID" \
   '{
-    evidence: $evidence,
+    evidence: ($evidence | to_entries | map(.value + {index: .key})),
+    acceptWith: "complete-task with \"verdict\":\"verified\" and \"checks\":[{\"entry\":<evidence index, or null for a direct look>,\"did\":\"<what you did and saw>\",\"outcome\":\"pass\"}] (#1314)",
     evidenceWarning: (if $evidenceWarning != "" then $evidenceWarning else null end),
     passed: ($passed == "true"),
     score: ($score | tonumber),

package/config/skills/team-leader/verify-output/execute.test.sh

@@ -126,6 +126,8 @@ echo "verify-output: evidence first (#873)"
 
 assert_json_field "evidence is the first key of the verdict" \
   '{"workItemId":"wi-ev"}' 'keys_unsorted[0]' 'evidence'
+assert_json_field "each evidence entry carries its index for the checks (#1314)" \
+  '{"workItemId":"wi-ev"}' '.evidence[1].index' '1'
 assert_json_field "evidence block is surfaced from output.evidence" \
   '{"workItemId":"wi-ev"}' '[.evidence[].type] | join(",")' 'artifact,command'
 assert_json_field "no evidence warning when evidence is present" \

package/dist/backend/backend/src/constants.d.ts

@@ -1779,12 +1779,20 @@ export declare const COMPLETION_EVIDENCE_CONSTANTS: {
     /** The two rollout modes for a completion that carries no evidence. */
     readonly MODES: readonly string[];
     /**
-     * Default mode for a completion with no evidence. `warn` (this release):
-     * accepted, logged, and the response carries a `warning`. `enforce` (next
-     * release): 400. Malformed evidence, missing artifacts, failing commands and
-     * `blocked` entries are handled the same in both modes.
+     * Default mode for a completion with no evidence. `enforce` (default since
+     * #1312): 400 `evidence_required`. `warn` (the escape hatch, set with
+     * {@link ENV_MODE}): accepted, logged, and the response carries a `warning`.
+     * Malformed evidence, missing artifacts, failing commands and `blocked`
+     * entries are handled the same in both modes.
      */
     readonly EVIDENCE_ENFORCEMENT_MODE: "warn" | "enforce";
+    /**
+     * WorkItem types whose completion must carry evidence: a worker's
+     * deliverable. Every other type is harness bookkeeping (triage, replans,
+     * retros, reconciles, notifications) and may complete without it. An item
+     * with no known type is treated as a deliverable.
+     */
+    readonly REQUIRED_FOR_TYPES: readonly string[];
     /** Env var that overrides {@link EVIDENCE_ENFORCEMENT_MODE} (`warn` | `enforce`). */
     readonly ENV_MODE: "CREWLY_EVIDENCE_MODE";
     /** Most evidence entries accepted on one completion. */
@@ -1800,8 +1808,25 @@ export declare const COMPLETION_EVIDENCE_CONSTANTS: {
         readonly MISSING: "evidence_required";
         readonly ARTIFACT_NOT_FOUND: "evidence_artifact_not_found";
         readonly ARTIFACT_UNRESOLVABLE: "evidence_artifact_relative_path";
+        readonly ARTIFACT_EMPTY: "evidence_artifact_empty";
+        readonly ARTIFACT_STALE: "evidence_artifact_stale";
         readonly COMMAND_FAILED: "evidence_command_failed";
-    };
+        readonly REVIEW_UNCHECKED: "review_unchecked";
+        readonly REVIEW_CHECKS_MALFORMED: "review_checks_malformed";
+        readonly REVIEW_CHECK_FAILED: "review_check_failed";
+    };
+    /** Worker evidence entries listed, numbered, in a review item's description (#1314). */
+    readonly REVIEW_LISTED_ENTRIES: 10;
+    /** Outcomes a reviewer records for one check (#1314). */
+    readonly CHECK_OUTCOMES: readonly string[];
+    /** The shape of a reviewer's check record, quoted in every refusal (#1314). */
+    readonly CHECKS_HINT: string;
+    /**
+     * A local file artifact last modified more than this before its WorkItem
+     * was created is stale: it was not made for this task (#1313). The slack
+     * covers clock skew and a file saved just before the item was filed.
+     */
+    readonly STALE_GRACE_MS: number;
     /** The shape a worker must send, quoted in every rejection and warning. */
     readonly SHAPE_HINT: string;
 };