crewly 1.20.419 → 1.20.421

package/config/skills/agent/core/project-tickets/SKILL.md

@@ -295,6 +295,27 @@ become backlog tickets on the Crewly project, deduplicated and at most 3 a
 day, and the owner approves them with one card. Never file harness gaps as
 tickets yourself.
 
+### Weekly cross-team retro (orchestrator)
+
+Once a week (Monday 09:00, or the first tick after) the orchestrator gets one
+`autopilot_retro` WorkItem titled `Weekly autopilot retro: <week>` when at
+least one lead filed a daily retro that ISO week. The brief lists every
+project's week numbers, its daily retro pages and the harness gaps filed. Read
+the pages, name what repeated across teams and what only Crewly can fix, then
+file it:
+
+```bash
+bash execute.sh retro --week 2026-W44 \
+  --summary "Three teams stalled on owner copy approvals; CE and Flopost both lost a day to a stopped member shown as busy." \
+  --problem "harness_gap|Triage brief shows stopped members as busy|Seen in CE 10-27 and Flopost 10-29 retros" \
+  --problem "owner_dependency|Copy approvals waited >3h in 4 of 7 days"
+```
+
+Same problem classes and limits as the daily retro. Crewly writes the page to
+the global wiki (`llm-curated/autopilot-retros/weekly/<week>.md`) and files the
+harness gaps on the Crewly project with one owner card. Only the owner or the
+orchestrator may file it.
+
 ### What to look for
 
 Read yesterday's run with `trace-read` first; each problem names the stage

package/config/skills/agent/core/project-tickets/execute.sh

@@ -31,6 +31,7 @@
 #   bash execute.sh stats     --project P [--days 14] [--label feed]       (owner / orc / lead)
 #   bash execute.sh runs      --project P [--days 7] [--label feed]        (owner / orc / lead)
 #   bash execute.sh retro     --project P --day YYYY-MM-DD --summary "…" [--problem "class|title|detail|evidence" …]
+#   bash execute.sh retro     --week YYYY-Www --summary "…" [--problem … …]   (orchestrator: weekly cross-team retro)
 #   bash execute.sh self-review --project P --gap "…" [--moved "…"] --next-bet "…"
 #   bash execute.sh '{"action":"create","project":"P","title":"…"}'
 #
@@ -100,6 +101,8 @@ Usage:
                                                               Team lead: file the daily autopilot retro.
                                                               class = agent_judgment | missing_skill |
                                                               harness_gap | owner_dependency
+  bash execute.sh retro     --week YYYY-Www --summary "…" [--problem … …]
+                                                              Orchestrator: file the weekly cross-team retro.
   bash execute.sh self-review --project P --gap "…" [--moved "…"] --next-bet "…"
                                                               Team lead: file the autopilot self-review (gap to
                                                               the target, what moved it, the next bet)
@@ -114,7 +117,7 @@ STATUS=""; SOURCE=""; REQUEST_ID=""; NOTE=""; OWNER_REVIEW=""; ASSIGNEE=""; STAR
 ACCEPTANCE_JSON="null"
 HAS_DESCRIPTION=0
 QUESTION=""; CLEAR=""; OPTIONS_JSON="[]"; DEFAULT_OPT=""; DEADLINE=""; SENSITIVE=""; AP_ENABLED=""; AP_DRIVER=""; AP_BUDGET=""; AP_MAX=""
-AP_RETRO=""; AP_REPLANS=""; AP_REPLAN_TTL=""; DAYS=""; LABEL=""; DAY=""; SUMMARY=""; PROBLEMS_JSON="[]"
+AP_RETRO=""; AP_REPLANS=""; AP_REPLAN_TTL=""; DAYS=""; LABEL=""; DAY=""; WEEK=""; SUMMARY=""; PROBLEMS_JSON="[]"
 DEFER_UNTIL=""; AP_SKIP=""; HOLD=""; HAS_HOLD=0
 METRIC=""; AP_SPEED=""; GAP=""; MOVED=""; NEXT_BET=""
 
@@ -211,6 +214,7 @@ while [[ $# -gt 0 ]]; do
     --days)          [ $# -ge 2 ] || error_exit "--days requires a value";        DAYS="$2"; shift 2 ;;
     --label)         [ $# -ge 2 ] || error_exit "--label requires a value";       LABEL="$2"; shift 2 ;;
     --day)           [ $# -ge 2 ] || error_exit "--day requires a value";         DAY="$2"; shift 2 ;;
+    --week)          [ $# -ge 2 ] || error_exit "--week requires YYYY-Www";       WEEK="$2"; shift 2 ;;
     --summary)       [ $# -ge 2 ] || error_exit "--summary requires a value";     SUMMARY="$2"; shift 2 ;;
     --problem)       [ $# -ge 2 ] || error_exit "--problem requires \"class|title|detail|evidence\""
                      PROBLEMS_JSON=$(jq -c --arg p "$2" '. + [($p | split("|")) as $f | {class: ($f[0] // "" | gsub("^\\s+|\\s+$"; "")), title: ($f[1] // "")} + (if ($f[2] // "") != "" then {detail: $f[2]} else {} end) + (if ($f[3:] | join("|")) != "" then {evidence: ($f[3:] | join("|"))} else {} end)]' <<<"$PROBLEMS_JSON"); shift 2 ;;
@@ -369,11 +373,17 @@ case "$ACTION" in
     fi
     ;;
   retro)
-    require_param "project" "$PROJECT"
-    require_param "day (--day YYYY-MM-DD)" "$DAY"
     require_param "summary (--summary)" "$SUMMARY"
-    BODY=$(jq -n --arg d "$DAY" --arg s "$SUMMARY" --argjson p "$PROBLEMS_JSON" '{day: $d, summary: $s, problems: $p}')
-    api_call POST "/project-ticket-autopilot/$(enc "$PROJECT")/retro" "$BODY" | jq '{success, retro: .data, error}'
+    if [ -n "$WEEK" ]; then
+      # Weekly cross-team retro (owner / orchestrator): no project, the week is the scope.
+      BODY=$(jq -n --arg w "$WEEK" --arg s "$SUMMARY" --argjson p "$PROBLEMS_JSON" '{week: $w, summary: $s, problems: $p}')
+      api_call POST "/project-ticket-autopilot/weekly-retro" "$BODY" | jq '{success, retro: .data, error}'
+    else
+      require_param "project" "$PROJECT"
+      require_param "day (--day YYYY-MM-DD)" "$DAY"
+      BODY=$(jq -n --arg d "$DAY" --arg s "$SUMMARY" --argjson p "$PROBLEMS_JSON" '{day: $d, summary: $s, problems: $p}')
+      api_call POST "/project-ticket-autopilot/$(enc "$PROJECT")/retro" "$BODY" | jq '{success, retro: .data, error}'
+    fi
     ;;
   self-review)
     require_param "project" "$PROJECT"

package/config/skills/agent/core/record-learning/SKILL.md

@@ -49,6 +49,14 @@ Record a learning or insight gained during task execution. These learnings are s
 | `--project` / `-p` | `projectPath` | Yes | Absolute path to the project |
 | `--learning` / `-l` | `learning` | Yes | The learning or insight (or pipe via stdin) |
 | `--learning-file` | — | No | Read learning from a file path |
+| `--class` | `correctionClass` | No | Correction class slug (e.g. `git-add-all`) when this learning records a **correction** — see below |
+| `--task` | `relatedTask` | No | Ticket / WorkItem the learning came from |
+
+## Corrections: give them a class
+
+When the learning is a correction — someone told you (or you found out) that a way of working was wrong — add `--class <slug>`: a short, stable name for the *kind* of mistake, not this instance of it (`git-add-all`, `skip-tests-before-pr`, `owner-thread-status-lines`). Reuse the same slug every time the same kind comes back; check with `GET /api/memory/corrections?projectPath=…` if unsure.
+
+Why: prose is read every turn and still lets the same mistake back in. The second time a class is recorded in a project, the team lead gets one WorkItem asking whether it can be made impossible (structural change), caught before merge (lint/test/CI), caught when it happens (hook), or must stay prose — and records the choice. Without a class, a correction is just another line in memory.
 
 ---
 
@@ -90,6 +98,9 @@ echo "Don't use git add -A — it catches .env files" | bash execute.sh --agent
 
 # Learning from file
 bash execute.sh --agent dev-1 --role developer --project /projects/app --learning-file /tmp/insight.txt
+
+# A correction, classed so a repeat reaches the team lead
+bash execute.sh --agent dev-1 --role developer --project /projects/app --class git-add-all --task CREW-42 --learning "[[git]] Never git add -A in this repo: it stages .env. Caught in CREW-42 review."
 ```
 
 ## Examples — Legacy JSON (backward compatible)
@@ -100,4 +111,4 @@ bash execute.sh '{"agentId":"dev-1","agentRole":"developer","projectPath":"/proj
 
 ## Output
 
-JSON confirmation that the learning was recorded.
+JSON confirmation that the learning was recorded. With `--class`, also `correction: { class, count, raised }` — `raised: true` means this occurrence sent the team lead the ladder WorkItem.

package/config/skills/agent/core/record-learning/execute.sh

@@ -22,6 +22,8 @@ AGENT_ID=""
 AGENT_ROLE=""
 PROJECT_PATH=""
 LEARNING=""
+CORRECTION_CLASS=""
+RELATED_TASK=""
 STRICT=0
 SKIP_PREFLIGHT=0
 
@@ -53,6 +55,14 @@ while [[ $# -gt 0 ]]; do
       LEARNING="$(cat "$2")"
       shift 2
       ;;
+    --class)
+      CORRECTION_CLASS="$2"
+      shift 2
+      ;;
+    --task)
+      RELATED_TASK="$2"
+      shift 2
+      ;;
     --strict)
       STRICT=1
       shift
@@ -67,7 +77,12 @@ while [[ $# -gt 0 ]]; do
       ;;
     --help|-h)
       cat <<'EOF'
-Usage: execute.sh --agent <id> --role <role> --project <path> --learning '<text>' [--strict] [--no-preflight]
+Usage: execute.sh --agent <id> --role <role> --project <path> --learning '<text>' [--class <slug>] [--task <id>] [--strict] [--no-preflight]
+
+  --class <slug>  This learning is a correction of kind <slug> (e.g. git-add-all).
+                  The second time a class is recorded, the team lead gets a
+                  WorkItem asking for a check in code instead of more prose (#810).
+  --task <id>     Ticket / WorkItem the learning came from.
 
 Karpathy-lite preflight rules (see SKILL.md):
   1. [[Entity]] opener (HARD)
@@ -113,6 +128,8 @@ if [ -n "$INPUT_JSON" ]; then
   [ -z "$AGENT_ROLE" ] && AGENT_ROLE=$(printf '%s' "$INPUT" | jq -r '.agentRole // empty')
   [ -z "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
   [ -z "$LEARNING" ] && LEARNING=$(printf '%s' "$INPUT" | jq -r '.learning // empty')
+  [ -z "$CORRECTION_CLASS" ] && CORRECTION_CLASS=$(printf '%s' "$INPUT" | jq -r '.correctionClass // empty')
+  [ -z "$RELATED_TASK" ] && RELATED_TASK=$(printf '%s' "$INPUT" | jq -r '.relatedTask // empty')
   if [ "$STRICT" -eq 0 ]; then
     JSON_STRICT=$(printf '%s' "$INPUT" | jq -r '.strict // empty')
     [ "$JSON_STRICT" = "true" ] && STRICT=1
@@ -176,12 +193,17 @@ export _LRN_ROLE="$AGENT_ROLE"
 export _LRN_PROJECT="$PROJECT_PATH"
 export _LRN_CONTENT="$LEARNING"
 export _LRN_STRICT="$STRICT"
+export _LRN_CLASS="$CORRECTION_CLASS"
+export _LRN_TASK="$RELATED_TASK"
 
 if [ "$STRICT" -eq 1 ]; then
   BODY=$(jq -n '{agentId: env._LRN_AGENT, agentRole: env._LRN_ROLE, projectPath: env._LRN_PROJECT, learning: env._LRN_CONTENT, strict: true}')
 else
   BODY=$(jq -n '{agentId: env._LRN_AGENT, agentRole: env._LRN_ROLE, projectPath: env._LRN_PROJECT, learning: env._LRN_CONTENT}')
 fi
-unset _LRN_AGENT _LRN_ROLE _LRN_PROJECT _LRN_CONTENT _LRN_STRICT
+# Optional fields: a correction class (ladder, #810) and the task it came from.
+[ -n "$CORRECTION_CLASS" ] && BODY=$(printf '%s' "$BODY" | jq '. + {correctionClass: env._LRN_CLASS}')
+[ -n "$RELATED_TASK" ] && BODY=$(printf '%s' "$BODY" | jq '. + {relatedTask: env._LRN_TASK}')
+unset _LRN_AGENT _LRN_ROLE _LRN_PROJECT _LRN_CONTENT _LRN_STRICT _LRN_CLASS _LRN_TASK
 
 api_call POST "/memory/record-learning" "$BODY"

package/config/skills/team-leader/decide-correction/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: Decide Correction
+description: "Record which rung of the correction ladder closes a repeated correction class: structural change, lint/test/CI check, state-triggered hook, or prose with a stated reason (#810)."
+version: 1.0.0
+category: management
+skillType: claude-skill
+assignableRoles:
+  - team-leader
+triggers:
+  - decide correction
+  - correction ladder
+  - make it impossible
+  - add a check for this
+tags:
+  - correction
+  - ladder
+  - quality
+  - management
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 15000
+---
+
+# Decide Correction
+
+The correction ladder counts corrections per **class** (a short slug such as `git-add-all`) in each project. The second time a class is recorded you receive a WorkItem: the same kind of mistake came back, and prose (memory, SOP, prompt) did not stop it. This skill records your answer and closes the ladder for that class.
+
+## The rungs, highest first
+
+| Rung | Meaning | Example |
+|------|---------|---------|
+| `structural` | Change the API, type or file layout so the mistake can no longer be expressed | the helper takes a typed enum instead of a free string |
+| `check` | A lint rule, test or CI step fails before merge | an ESLint rule, a test that greps for `git add -A` in scripts |
+| `hook` | A state-triggered hook or skill guard catches it the moment it happens | a pre-commit hook; a skill script that refuses the argument |
+| `prose` | Keep it as memory/SOP text — with the reason nothing above is worth it | "happens once a quarter, the fix costs more than the mistake" |
+
+Do the work for the rung you pick (or open the PR / ticket for it) **first**, then record the choice with the link. A `prose` decision is not final: if the class comes back twice more, the ladder raises it again and names your earlier reason.
+
+## Usage
+
+```bash
+bash {{SKILLS_PATH}}/team-leader/decide-correction/execute.sh \
+  --project /projects/app --class git-add-all --rung check \
+  --reason "test in scripts.test.ts fails on 'git add -A'" --link https://github.com/org/repo/pull/321
+```
+
+## Parameters
+
+| Flag | JSON Field | Required | Description |
+|------|-----------|----------|-------------|
+| `--project` / `-p` | `projectPath` | Yes | Absolute project root the class was recorded in |
+| `--class` / `-c` | `correctionClass` | Yes | The class slug from the WorkItem title |
+| `--rung` / `-r` | `rung` | Yes | `structural`, `check`, `hook` or `prose` |
+| `--reason` | `reason` | Yes | Why this rung (required for every rung) |
+| `--link` | `link` | No | PR, file, rule or hook that implements it |
+| `--by` | `decidedBy` | No | Your session name (default `$CREWLY_SESSION_NAME`) |
+
+## Output
+
+The class record: tally, occurrences, and the decision just made. To see every class of a project: `GET /api/memory/corrections?projectPath=<root>`.
+
+The owner is not involved in ladder decisions. Never post them in the owner's thread.

package/config/skills/team-leader/decide-correction/execute.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# Record the team lead's rung for a correction class (#810).
+#   execute.sh --project <root> --class <slug> --rung <structural|check|hook|prose> --reason '<why>' [--link <url>] [--by <session>]
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+INPUT_JSON=""
+PROJECT_PATH=""
+CLASS=""
+RUNG=""
+REASON=""
+LINK=""
+BY="${CREWLY_SESSION_NAME:-}"
+
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --project|-p) PROJECT_PATH="$2"; shift 2 ;;
+    --class|-c) CLASS="$2"; shift 2 ;;
+    --rung|-r) RUNG="$2"; shift 2 ;;
+    --reason) REASON="$2"; shift 2 ;;
+    --link) LINK="$2"; shift 2 ;;
+    --by) BY="$2"; shift 2 ;;
+    --json|-j) INPUT_JSON="$2"; shift 2 ;;
+    --help|-h)
+      echo "Usage: execute.sh --project <root> --class <slug> --rung <structural|check|hook|prose> --reason '<why>' [--link <url>] [--by <session>]"
+      exit 0
+      ;;
+    *) unknown_arg_exit "$1" ;;
+  esac
+done
+
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+  [ -z "$CLASS" ] && CLASS=$(printf '%s' "$INPUT" | jq -r '.correctionClass // empty')
+  [ -z "$RUNG" ] && RUNG=$(printf '%s' "$INPUT" | jq -r '.rung // empty')
+  [ -z "$REASON" ] && REASON=$(printf '%s' "$INPUT" | jq -r '.reason // empty')
+  [ -z "$LINK" ] && LINK=$(printf '%s' "$INPUT" | jq -r '.link // empty')
+  [ -z "$BY" ] && BY=$(printf '%s' "$INPUT" | jq -r '.decidedBy // empty')
+fi
+
+require_param "projectPath (--project)" "$PROJECT_PATH"
+require_param "correctionClass (--class)" "$CLASS"
+require_param "rung (--rung)" "$RUNG"
+require_param "reason (--reason)" "$REASON"
+[ -z "$BY" ] && BY="team-leader"
+
+case "$RUNG" in
+  structural|check|hook|prose) ;;
+  *) error_exit "rung must be one of structural, check, hook, prose (got: $RUNG)" ;;
+esac
+
+export _DC_PROJECT="$PROJECT_PATH" _DC_RUNG="$RUNG" _DC_REASON="$REASON" _DC_LINK="$LINK" _DC_BY="$BY"
+BODY=$(jq -n '{projectPath: env._DC_PROJECT, rung: env._DC_RUNG, reason: env._DC_REASON, decidedBy: env._DC_BY} + (if env._DC_LINK != "" then {link: env._DC_LINK} else {} end)')
+unset _DC_PROJECT _DC_RUNG _DC_REASON _DC_LINK _DC_BY
+
+api_call POST "/memory/corrections/$(printf '%s' "$CLASS" | jq -sRr @uri | tr -d '\n')/decide" "$BODY"

package/config/skills/team-leader/handle-failure/SKILL.md

@@ -50,6 +50,7 @@ bash {{SKILLS_PATH}}/team-leader/handle-failure/execute.sh '{"workerId":"worker-
 | `teamId` | No | Team ID (needed for reassignment lookup) |
 | `requiredRole` | No | Role required for the task (helps find alternatives) |
 | `taskDescription` | No | Brief task description for context |
+| `projectPath` | No | Project root; with `failureInfo.correctionClass`, the failure is counted on the project's correction ladder (#810) |
 | `failureInfo` | Yes | Failure details object (see below) |
 
 ### failureInfo Object
@@ -60,6 +61,7 @@ bash {{SKILLS_PATH}}/team-leader/handle-failure/execute.sh '{"workerId":"worker-
 | `failedSteps` | Array of failed verification step names |
 | `retries` | Number of retries already attempted |
 | `failureType` | Category of failure (see below) |
+| `correctionClass` | Optional. A short slug for the *kind* of mistake behind the failure (`skip-tests-before-pr`, `git-add-all`). Give one when the failure was a correction of how the worker works, not a flaky environment. The second time a class is recorded in a project you (the lead) get one WorkItem asking whether it can be made impossible, caught by a check or a hook, or must stay prose — answered with `decide-correction`. The output carries `correction: { class, count, raised }`. |
 
 ### Failure Types
 

package/config/skills/team-leader/handle-failure/execute.sh

@@ -19,6 +19,11 @@ RETRIES=$(printf '%s' "$INPUT" | jq -r '.failureInfo.retries // 0')
 FAILURE_TYPE=$(printf '%s' "$INPUT" | jq -r '.failureInfo.failureType // "unknown"')
 ERROR_MSG=$(printf '%s' "$INPUT" | jq -r '.failureInfo.error // "Unknown error"')
 FAILED_STEPS=$(printf '%s' "$INPUT" | jq -c '.failureInfo.failedSteps // []')
+# Correction ladder (#810): a classed failure is counted per project; the
+# second occurrence of a class sends this lead a WorkItem asking for a check
+# in code instead of another retry note.
+CORRECTION_CLASS=$(printf '%s' "$INPUT" | jq -r '.failureInfo.correctionClass // empty')
+PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
 
 require_param "workerId" "$WORKER_ID"
 
@@ -97,6 +102,17 @@ if [ "$ACTION" = "reassign" ] && [ -n "$TEAM_ID" ]; then
   fi
 fi
 
+# Correction ladder (#810): count the classed failure; the answer says whether
+# this occurrence raised the ladder WorkItem. Never fails the decision.
+CORRECTION_JSON="null"
+if [ -n "$CORRECTION_CLASS" ] && [ -n "$PROJECT_PATH" ]; then
+  export _HF_PROJECT="$PROJECT_PATH" _HF_CLASS="$CORRECTION_CLASS" _HF_AGENT="${WORKER_SESSION:-$WORKER_ID}" _HF_TEXT="$ERROR_MSG" _HF_TASK="$TASK_DESCRIPTION"
+  CORR_BODY=$(jq -n '{projectPath: env._HF_PROJECT, correctionClass: env._HF_CLASS, agentId: env._HF_AGENT, text: env._HF_TEXT, source: "failure"} + (if env._HF_TASK != "" then {relatedTask: env._HF_TASK} else {} end)')
+  unset _HF_PROJECT _HF_CLASS _HF_AGENT _HF_TEXT _HF_TASK
+  CORRECTION_JSON=$( (api_call POST "/memory/corrections" "$CORR_BODY" 2>/dev/null || true) | jq -c '.data // null' 2>/dev/null || true)
+  [ -z "$CORRECTION_JSON" ] && CORRECTION_JSON="null"
+fi
+
 # Output decision
 jq -n \
   --arg action "$ACTION" \
@@ -106,8 +122,10 @@ jq -n \
   --arg originalWorkerId "$WORKER_ID" \
   --arg failureType "$FAILURE_TYPE" \
   --arg retries "$RETRIES" \
+  --argjson correction "$CORRECTION_JSON" \
   '{
     action: $action,
+    correction: $correction,
     nextWorkerId: (if $nextWorkerId != "" then $nextWorkerId else null end),
     nextWorkerSession: (if $nextWorkerSession != "" then $nextWorkerSession else null end),
     instructions: $instructions,

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

@@ -152,6 +152,16 @@ export declare const TICKET_AUTOPILOT_CONSTANTS: {
     /** Option labels of that card */
     readonly RETRO_APPROVE_LABEL: "Approve";
     readonly RETRO_SKIP_LABEL: "Skip";
+    /** `metadata.kind` of the weekly retro WorkItem (same WorkItem type as the daily retro) */
+    readonly WEEKLY_RETRO_METADATA_KIND: "autopilot_weekly_retro";
+    /** Local weekday (0 = Sunday) on or after which, at RETRO_HOUR_LOCAL, the previous ISO week's retro is scheduled */
+    readonly WEEKLY_RETRO_WEEKDAY_LOCAL: 1;
+    /** Global-vault folder the weekly retros are written to */
+    readonly WEEKLY_RETRO_WIKI_DIR: "llm-curated/autopilot-retros/weekly";
+    /** Most projects listed in detail in the weekly brief (the rest are counted) */
+    readonly WEEKLY_RETRO_MAX_PROJECTS_IN_BRIEF: 12;
+    /** How long filed daily retros are remembered (days) — the weekly retro reads them */
+    readonly RETRO_FILED_MEMORY_DAYS: 60;
     /** WorkItem type / `metadata.kind` of the goal replan the driver receives when nothing is left to triage */
     readonly REPLAN_WORK_ITEM_TYPE: "goal_replan";
     readonly REPLAN_METADATA_KIND: "goal_replan";
@@ -2181,6 +2191,31 @@ export declare const WIKI_GAPS_CONSTANTS: {
     /** Session that authors the page. */
     readonly CALLER_SESSION: "system:wiki-knowledge-gaps";
 };
+/**
+ * Correction ladder (#810): repeated corrections of one class become a
+ * team-lead WorkItem asking for a check in code instead of more prose.
+ */
+export declare const CORRECTION_LADDER_CONSTANTS: {
+    /** Per-project store, under the project data dir */
+    readonly STORE_FILE: "correction-ladder.json";
+    /** Occurrences of a class (or after a prose decision) that raise the lead's WorkItem */
+    readonly THRESHOLD: 2;
+    /** An undecided WorkItem older than this is treated as abandoned and raised again */
+    readonly REOPEN_AFTER_MS: number;
+    /** The rungs, highest first: make it impossible → catch before merge → catch when it happens → tell them again */
+    readonly RUNGS: readonly ["structural", "check", "hook", "prose"];
+    /** Class slug bounds */
+    readonly CLASS_MIN_CHARS: 2;
+    readonly CLASS_MAX_CHARS: 48;
+    /** Occurrences kept per class (newest) */
+    readonly MAX_OCCURRENCES_KEPT: 20;
+    /** Occurrences quoted in the lead's brief */
+    readonly OCCURRENCES_IN_BRIEF: 5;
+    /** Correction text kept per occurrence */
+    readonly OCCURRENCE_TEXT_MAX_CHARS: 400;
+    /** WorkItem `metadata.kind` */
+    readonly WORKITEM_KIND: "correction-ladder";
+};
 /**
  * Daily agent-memory refresh (#1345): what an agent recorded in the wiki
  * log is reflected into its `memory.json` and the project's memory.