kc-nightwatch

name: kc-nightwatch description: Use when running nightly plugin improvement cycle — forge validation, signal harvesting, north-star gap analysis, auto-fix and proposal generation. Triggered by cron or manual invocation.

kc-nightwatch — Nightly Plugin Improvement

Autonomous nightly pipeline that patrols each plugin, fixes structural issues, and proposes north-star-aligned improvements.

Core philosophy: Find cracks in the wall and patch them nightly. Never tear down a wall.

Arguments

Parse the invocation arguments:

• /kc-nightwatch — production mode (all safety guards active)
• /kc-nightwatch --self-repair — self-repair mode: validate config, collect feedback, check own forge status. Runs as Phase SR (before Phase 0). Does NOT run the regular pipeline.
• /kc-nightwatch --dry-run — dry-run mode: bypasses skip_if_dirty and skip_if_recent_human_commit guards. Combinable with any mode.

When --dry-run is active, prefix all log output with [DRY-RUN]. When --self-repair is active, prefix all log output with [SELF-REPAIR].

Mode routing:

• --self-repair → execute Phase SR only, then stop
• no args / --dry-run only → execute Phase 0-5 (existing pipeline)

Prerequisites Check

Before starting, check for optional plugin dependencies:

• kc-plugin-forge — invoke Skill: "kc-plugin-forge" with validate-only (used in Phase 1)

If kc-plugin-forge is not loaded:

[WARN] kc-plugin-forge not loaded — Phase 1 (forge validation) will be skipped

Set forge_available = false and continue. Phase 1 will be skipped entirely.

Phase SR: Self-Repair (--self-repair mode only)

Runs in a dedicated session before the regular pipeline. Three responsibilities:

1. Config validation + auto-fix
2. Feedback collection from previous runs
3. Own plugin forge check

Step SR.1: Load Self-Repair Config

Read:

1. ~/.claude/kc-plugins-config/nightwatch-targets.yaml — targets to validate
2. config/safety.yaml → self_repair section — limits and matching algorithm
3. ~/.claude/kc-plugins-config/nightwatch-improvement-log.md → last_run timestamp (for feedback scan window)

Step SR.2: Config Validation + Auto-Fix

For each target in nightwatch-targets.yaml:

Checks to perform:

Name resolution matching algorithm (from safety.yaml):

1. Fetch all teams/projects from Linear MCP
2. For the configured value, try in order: a. Exact match → use it (no fix needed) b. Case-insensitive exact match → auto-fix, log correction c. Single substring match (configured value is substring of exactly one result) → auto-fix, log correction d. 2+ substring matches → ambiguous, skip — log all candidates e. Zero matches → skip — log error

Before modifying nightwatch-targets.yaml:

cp ~/.claude/kc-plugins-config/nightwatch-targets.yaml \
   ~/.claude/kc-plugins-config/nightwatch-targets.yaml.bak

Cap: max self_repair.max_config_fixes corrections per run (default: 3). After reaching the cap, log remaining issues without fixing.

Linear/Sentry MCP unavailable: If Linear or Sentry MCP tools are not available in this session, skip those checks — log: [SELF-REPAIR] Linear MCP unavailable, skipping team/project validation. Do NOT fail the entire self-repair phase.

Step SR.3: Feedback Collection

Scan nightwatch's own output from previous runs to close the feedback loop.

PR feedback — for each repo that has a remote:

gh pr list --label kc-nightwatch --state all --limit 10 --json number,title,state,comments,reviews,mergedAt,closedAt

For each PR updated since last_run:

• Merged (no review comments) → status: accepted
• Merged (with review comments) → status: corrected, extract correction summary
• Closed without merge → status: rejected
• Still open → skip (not yet resolved)

Extract the signal_id from the PR body (nightwatch PRs include signal ID in the description).

Linear issue feedback — for each target with linear_team:

list_issues: team={linear_team}, labels=["nightwatch"], includeArchived: true

For each issue updated since last_run:

• Done / Completed → status: accepted
• Won't fix / Canceled → status: rejected, cooldown_override: 30d
• Duplicate → status: duplicate, follow to original issue
• Still open → skip

Aggregate reject rates:

For each proxy signal that has 3+ historical feedback entries in nightwatch-improvement-log.md:

• Count accepted vs rejected
• Calculate reject rate: rejected / (accepted + rejected)
• Store in aggregates

Write output to ~/.claude/kc-plugins-config/nightwatch-feedback.yaml:

collected_at: {ISO 8601 timestamp}
pr_feedback:
  - signal_id: {id}
    status: {accepted | rejected | corrected}
    source: "{PR #N description}"
    cooldown_override: null  # or "30d" for rejected
linear_feedback:
  - signal_id: {id}
    status: {accepted | rejected | duplicate}
    source: "{issue identifier}"
    cooldown_override: null
aggregates:
  proxy_signal_reject_rates:
    {proxy_signal_id}: {float 0.0-1.0}

If no feedback found, write file with empty lists (the file existing with collected_at is the signal that self-repair ran).

Step SR.4: Own Plugin Forge Check

Run forge validate-only on kc-nightwatch itself. This replaces the v0.1 self-monitoring exclusion.

Prerequisites: kc-plugin-forge must be loaded in this session. If not → log warning and skip.

Skill: "kc-plugin-forge" args: "validate-only {kc-nightwatch plugin path}"

Scope restriction: Only act on structural FAIL items (plugin.json schema, missing required files). Do NOT fix behavioral skill content (that goes through the normal proposal pipeline).

If FAIL (structural):

1. Create branch: kc-nightwatch/$(date +%Y-%m-%d)-self-forge-fix
2. Apply fixes (subject to auto_fix.allowed_operations and auto_fix.max_files_per_plugin)
3. Re-validate with forge
4. If still FAIL → revert, log failure
5. If PASS → commit, return to main
6. Circuit breaker: max self_repair.max_self_fix_prs PRs (default: 1)

If PASS: log [SELF-REPAIR] forge: PASS and continue.

Step SR.5: Write Self-Repair Output

Write all results to ~/.claude/kc-plugins-config/nightwatch-self-repair.yaml:

run_date: {ISO 8601 timestamp}
config_fixes:
  - target: {name}
    field: {field_name}
    before: "{old value}"
    after: "{new value}"
    method: "{exact | case-insensitive | single-substring}"
config_warnings:
  - target: {name}
    field: {field_name}
    error: "{error description}"
    suggestion: "{what user should do}"
forge_result:
  status: {pass | fail | skipped}
  branch: null  # or branch name if PR created
  details: "{if fail, what failed}"
feedback_collected:
  prs_scanned: {count}
  issues_scanned: {count}
  new_feedback_entries: {count}

Report completion:

[SELF-REPAIR] complete
  Config fixes: {count}
  Config warnings: {count}
  Forge: {pass/fail/skipped}
  Feedback: {prs_scanned} PRs, {issues_scanned} issues → {new_feedback_entries} new entries

Phase 0: Preflight

Step 0.1: Load Configuration

Read these files:

1. ~/.claude/kc-plugins-config/nightwatch-targets.yaml — monitoring targets with paths, keywords, proxy signals, type, sources, actions
2. config/safety.yaml (from kc-nightwatch plugin directory) — all safety boundaries and limits
3. ~/.claude/kc-plugins-config/nightwatch-improvement-log.md (from kc-nightwatch plugin directory) — last run results and cooldown data
4. ~/.claude/kc-plugins-config/language.yaml — output language preferences (shared across kc-plugins)
5. ~/.claude/kc-plugins-config/nightwatch-feedback.yaml (optional) — feedback from self-repair session. If file exists and collected_at is within the last 24h, apply these adjustments:
   • For each proxy signal in aggregates.proxy_signal_reject_rates:
     • Rate > 0.5 → only process confidence: high signals for this proxy signal (drop medium)
     • Rate ≤ 0.5 → keep default threshold (medium and above)
   • For each entry with cooldown_override: 30d → extend that signal's cooldown from 7d to 30d
   • If file doesn't exist or collected_at is stale (>24h) → no adjustments (default behavior)

Language resolution: For each target, resolve the output language:

1. Match target's path against overrides entries in language.yaml (longest prefix match)
2. If no override matches → use default (typically en)
3. Store the resolved language per target for use in Phase 4 (Linear issue title/description, Slack report text) and Phase 5 (Slack morning report)

Target filtering: Only process targets whose type and actions are supported by the current version. In v0.3, supported types: plugin, product. Supported actions: quick-fix, proposal, linear-issue, alert, e2e-flow. Skip targets whose actions list is empty or contains unknown action types.

Store the safety values for reference throughout execution:

• auto_fix.max_files_per_plugin: max files to auto-fix per plugin
• auto_fix.allowed_operations: what file operations are allowed for auto-fix
• proposal.max_per_plugin: max proposals per plugin
• e2e_flow.max_files_per_target: max flow YAML files to create per target (default: 1)
• e2e_flow.require_existing_mapping: whether to require existing .claude/e2e/mappings/
• alert.max_per_target: max alert signals per target per run (default: 5)
• global.skip_if_dirty: whether to skip plugins with uncommitted changes
• global.skip_if_recent_human_commit: time threshold for recent human commits
• global.cooldown_per_signal: cooldown period for signal deduplication

Step 0.2: Resolve Target Paths

For type: plugin targets — path field is optional. Resolve source path automatically:

1. Check ~/.claude/plugins/local/{target_name}:

   readlink -f ~/.claude/plugins/local/{target_name} 2>/dev/null
   

   If it's a symlink → resolved path is the source directory. If it's a regular directory AND is a git repo → use it as source. If it's a regular directory but NOT a git repo → it's a copy, continue to step 2.

2. Scan $KC_WORKSPACE (if env var is set) for the plugin:

   find "$KC_WORKSPACE" -path "*/{target_name}/.claude-plugin/plugin.json" -maxdepth 4 2>/dev/null | head -1
   

   Extract parent directory as source path.

3. If still not found → log warning and skip: [WARN] Cannot resolve source path for {target_name} — skipping

4. If target has an explicit path field → use it directly (override auto-resolution).

Store for each plugin target:

• path — resolved source directory (e.g., ~/Project/workspace/kc-claude-plugins/kc-pr-flow)
• repo_root — git repo root: git -C {path} rev-parse --show-toplevel
• repo — from target config if set, otherwise basename of repo_root
• has_remote — git -C {repo_root} remote get-url origin 2>/dev/null succeeds

For type: product targets — path is required. Resolve:

1. Expand ~ in path to absolute path
2. Verify the directory exists
3. Verify it's a git repo

If a target path is invalid, log a warning and skip it (do not abort the entire run).

Step 0.3: Check Skip Conditions (per plugin)

If --dry-run mode: Skip all guard checks below. All verified plugins become active. Log: [DRY-RUN] Bypassing skip guards — all plugins active

If production mode: For each plugin:

skip_if_dirty check:

cd {plugin_repo_root} && git diff --quiet HEAD

If exit code is non-zero (tracked files have uncommitted changes) → skip ALL plugins in this repo. Log: Skipping {plugin}: uncommitted changes detected

Note: This uses git diff --quiet HEAD instead of git status --porcelain to ignore untracked files. Untracked files don't affect git branch/checkout operations and should not block nightwatch.

skip_if_recent_human_commit check:

cd {plugin_repo_root} && git log -1 --format="%aI" --no-merges

Parse the timestamp. If the most recent commit is within skip_if_recent_human_commit (default: 2h) of now → skip this plugin. Log: Skipping {plugin}: recent human commit at {timestamp}

IMPORTANT: Check BOTH conditions. A plugin can be skipped for either reason.

Build the list of active plugins (those that passed both checks).

If zero active plugins remain → log kc-nightwatch: all plugins skipped — silent night and proceed directly to Phase 5 (output a "no changes" report).

Step 0.4: Scan Feedback from Previous Runs

Check if nightwatch's previous output received responses. This closes the feedback loop — rejected or corrected signals inform future classification.

PR feedback (repos with remote):

For each repo that has a remote, search for nightwatch PR comments:

gh pr list --label kc-nightwatch --state all --limit 10 --json number,title,state,comments,reviews

For each PR with new comments or reviews since last_run:

• Rejected (PR closed without merge + negative comment): add signal ID to ~/.claude/kc-plugins-config/nightwatch-improvement-log.md with feedback: rejected and extend cooldown to 30 days
• Correction (PR merged but with review comments suggesting a different approach): log feedback: corrected with the correction summary — future signals on the same proxy signal will use this context
• Approved (PR merged, no issues): log feedback: accepted — confirms signal quality

Linear issue feedback:

For each target with linear_project configured:

list_issues: project={linear_project}, labels=["nightwatch"], state="done", updated_after={last_run}

For each resolved issue:

• Won't fix / Not planned: add signal ID with feedback: rejected, extend cooldown to 30 days
• Duplicate: log feedback: duplicate with the original issue ID — merge signal references
• Done: log feedback: accepted

Store feedback in improvement-log.md:

Add a ## Feedback section under the run date:

## Feedback (from previous runs)

- signal: sig-20260315-003
  feedback: rejected
  source: PR #1 closed with comment "not applicable to our setup"
  cooldown_override: 30d

- signal: sig-20260314-001
  feedback: accepted
  source: Linear SC-XXX completed

Impact on Phase 3: When classifying signals in Step 3.2 (Cooldown Check), check the feedback field:

• rejected → signal is in permanent cooldown (30d) regardless of the default 7d
• corrected → use correction context to adjust confidence (typically downgrade by one level)
• accepted → no change (confirms the signal was valuable)

Step 0.4.5: Collect Slack Reaction Feedback

Purpose: Read reactions on the previous run's Slack morning report and convert them to feedback entries. This implements EXTFEED-01 (D-09, D-12).

Prerequisites: Step 0.1 must have loaded the improvement-log. Step 0.4 must have completed (PR/Linear feedback scanned first).

Step 1 — Find previous Slack message URL:

Read ~/.claude/kc-plugins-config/nightwatch-improvement-log.md and find the most recent run entry that has a slack_url field with a non-null value.

• If no slack_url found in any recent entry → skip silently. This is expected for silent nights or when Slack delivery failed. Do NOT log a warning.
• If slack_url: null → skip silently (same reason).

Step 2 — Read reactions via Slack MCP:

Call slack_read_thread with the Slack message URL from Step 1. The slack_read_thread tool returns the message reactions (emoji name + users list).

If the MCP tool is not available in this session → log [WARN] Slack MCP unavailable — skipping reaction feedback collection and continue to Phase 0.5.

If the MCP call fails (timeout, auth error, channel not found) → log [WARN] Slack reaction collection failed: {error} — skipping and continue to Phase 0.5. Never block Phase 1+.

Abstraction note (D-10): Steps 3-5 are backend-agnostic. To replace Slack MCP with Bot API (fetch + SLACK_BOT_TOKEN), only Step 2 needs changing — the rest of the pipeline stays the same.

Step 3 — Map reactions to verdicts (per D-02):

For each slack_reaction emoji returned by slack_read_thread:

Dedup rule: If the same user reacted with multiple mapped reactions, take the strongest signal: rejected > uncertain > accepted. Rationale: a thumbsdown overrides a thumbsup from the same person.

Step 4 — Write FeedbackEntries:

For each mapped slack_reaction (after dedup), append a FeedbackEntry to ~/.claude/kc-plugins-config/nightwatch-feedback.yaml:

- signal_id: "{from improvement-log — use the first signal_id in that run's entries, or 'run-{date}' if no signals}"
  target: "{target name from improvement-log entry, or 'nightwatch-report' for run-level reactions}"
  run_id: "{run date from improvement-log, e.g., 2026-03-24}"
  verdict: "{mapped verdict}"
  reason: "Slack reaction: {emoji_name} by {user}"
  source: "slack_reaction"
  submitted_at: "{current ISO 8601 timestamp}"

Append under the slack_feedback key in the feedback YAML (this key is created by Plan 14-01's FeedbackStore routing).

Signal_id correlation: The Slack morning report covers all targets in a single message. For per-signal correlation:

• If the improvement-log entry for that run has exactly 1 signal → use that signal_id
• If the improvement-log entry has multiple signals → use run-{date} as a synthetic signal_id (the reaction is on the whole report, not a specific signal)
• The dashboard will display these as run-level feedback

Step 5 — Log results:

[PHASE 0] Slack reactions collected: {count} entries from {emoji_count} reactions ({accepted_count} accepted, {rejected_count} rejected, {uncertain_count} uncertain)

If zero mapped reactions found → log [PHASE 0] Slack reactions: none found on previous report (info, not warning).

Phase 0.5: Indicator Baseline Measurement

Purpose: Measure quantified indicator values BEFORE any actions, providing a baseline to compare against after the run.

For each active target's indicators list (from nightwatch-targets.yaml), measure the current value:

1. Read the target's indicators from nightwatch-targets.yaml. Each indicator has id and description.
2. For each indicator, attempt to measure its current value using available tools:
   • Test coverage: run bun test --coverage or read last coverage report
   • Git churn: count commits in last 7 days via git log --oneline --since="7 days ago" | wc -l
   • Open issues: count via gh issue list --state open --json number | jq length
   • Lint warnings: run linter in count mode
   • If measurement fails, log warning and skip that indicator
3. Compute trend by comparing against the previous run's baseline (from nightwatch-feedback.yaml under baselines: key):
   • Value improved → trend: improving
   • Value unchanged (within 5%) → trend: stable
   • Value worsened → trend: degrading
   • No previous value → trend: stable (first measurement)
4. Store baselines in the run's structured output (written to summary.yaml in Phase 5)

Output format (YAML, written as part of summary.yaml per-target section):

indicator_baseline:
  test-coverage:
    value: 85
    measurement: "percent"
    previous_value: 82
    trend: improving
  open-issues:
    value: 12
    measurement: "count"
    previous_value: 15
    trend: improving

If a target has no indicators defined, skip Phase 0.5 for that target and leave indicator_baseline: {}.

Phase 1: Forge Validation

Skip entirely if forge_available = false — log [SKIP] Phase 1: kc-plugin-forge not loaded and proceed to Phase 2.

Only for type: plugin targets. Product targets skip Phase 1 entirely — proceed directly to Phase 2.

For each active plugin target (can be parallel):

Step 1.1: Run Forge Validate-Only

Skill: "kc-plugin-forge" args: "validate-only {plugin_path}"

If the skill invocation fails (not loaded, error), log the error and skip this plugin for Phase 1.

Step 1.2: Handle FAIL Items

If forge reports any FAIL items:

1. Create a fix branch:

   cd {plugin_repo_root}
   git checkout -b kc-nightwatch/$(date +%Y-%m-%d)-{plugin_name}-forge-fix
   

2. Auto-fix each FAIL item, subject to these constraints:

   • Maximum auto_fix.max_files_per_plugin files (read from safety.yaml)
   • Only auto_fix.allowed_operations operations (default: [edit] — NO create, NO delete)
   • If more FAIL items exist than the file limit allows, prioritize by severity (structural > cosmetic)

3. Re-validate after fixing:

   Skill: "kc-plugin-forge" args: "validate-only {plugin_path}"
   

   If still FAIL → revert changes on this branch and log: Auto-fix failed for {plugin}: forge still reports FAIL after fixes

4. Commit to branch:

   git add {changed_files}
   git commit -m "kc-nightwatch: fix {summary_of_fixes}"
   

5. Return to main:

   git checkout main
   

Step 1.3: PASS → Proceed

If forge reports PASS (or PASS after auto-fix), mark this plugin as ready for Phase 2.

Safety Guards — Phase 1

Agent:
  subagent_type: kc-nightwatch:signal-harvester
  prompt: "Harvest signals for {name}. Keywords: {keywords}. North star: {north_star}. Proxy signals: {proxy_signals}. Plugin path: {path}. Repo: {repo}."
  model: sonnet

Agent:
  subagent_type: kc-nightwatch:sentry-scanner
  prompt: "Scan Sentry for {name}. Org: {sentry_org}. Projects: {sentry_projects}. Keywords: {keywords}. North star: {north_star}. Proxy signals: {proxy_signals}. Plugin path: {path}. Repo: {repo}."
  model: sonnet

Agent:
  subagent_type: kc-nightwatch:e2e-scanner
  prompt: "Scan E2E reports for {name}. Path: {path}. Keywords: {keywords}. North star: {north_star}. Proxy signals: {proxy_signals}. Plugin path: {path}. Repo: {repo}."
  model: sonnet

Agent:
  subagent_type: kc-nightwatch:git-scanner
  prompt: "Scan git stats for {name}. Path: {path}. Keywords: {keywords}. North star: {north_star}. Proxy signals: {proxy_signals}. Plugin path: {path}. Repo: {repo}."
  model: sonnet

pre_assessment: "3 high-priority signals identified targeting code quality and test coverage. Focusing on 2 code-fix actions (lint warnings, missing error handling) and 1 proposal (test infrastructure). Skipping 1 low-confidence churn signal. Expected to improve coverage by ~5% and reduce lint warnings to zero."

post_assessment: "Executed 2 of 3 planned actions. Code-fix for lint warnings succeeded (PR #47 created). Error handling fix succeeded (PR #48). Test infrastructure proposal deferred -- target repo has CI constraints that need manual resolution. Overall: code quality improved, test coverage unchanged."

cd {plugin_repo_root}
git remote -v

gh pr create --base main --head {branch_name} --title "kc-nightwatch: {summary}" --body "{description}" --label "kc-nightwatch"

## {YYYY-MM-DD}

slack_url: {full Slack message URL or null}

### {plugin_name}
- signal: {signal_id}
  action: quick-fix | proposal | linear-issue | e2e-flow | alert | auto-fix (Phase 1) | skipped
  branch: {branch_name}           # for quick-fix/proposal
  pr: {PR URL or "local branch"}  # for quick-fix/proposal
  issue: {issue identifier}       # for linear-issue
  files_changed: [{list}]         # for quick-fix
  reason: "{if skipped, why}"     # for skipped

targets_active: {count}
targets_skipped: {count}
total_signals: {count}
total_actions: {count}
errors: {count}
per_target:
  {target-name}:
    monitors:
      {monitor-name}:
        status: ok | error
        signals: {count}
    pipeline:
      found: {n}
      after_dedup: {n}
      after_confidence_filter: {n}
      after_cooldown: {n}
      classified: { code-fix: n, proposal: n, ... }
      executed: { code-fix: n, proposal: n, ... }
    actions:
      - signal_id: "{id}"
        type: "{type}"
        summary: "{description}"
        pr_url: "{url}"  # if PR created
        branch: "{branch}"  # if branch created
        indicator: "{indicator-id}"
        assessment:
          closer_to_north_star: yes | no | uncertain
          confidence: high | medium | low
          reasoning: "{prose explanation}"
    indicator_baseline:
      {indicator-id}:
        value: {number}
        measurement: "{unit}"
        previous_value: {number}  # from last run, if available
        trend: improving | stable | degrading
    pre_assessment: "{strategy prose from Phase 3.5}"
    post_assessment: "{reflection prose from Phase 4.5}"
    implementation_outcomes: []

runs:
  - date: {ISO 8601 timestamp}
    mode: {production | dry-run}
    duration_seconds: {elapsed time}
    targets:
      {target_name}:
        agents:
          {agent_name}: {status: ok | failed | empty, signals: N}
          # failed agents include: reason: "{error message}"
          # empty agents include: note: "{why empty}"
        pipeline:
          found: {total signals from all agents}
          after_dedup: {after cross-source dedup}
          after_confidence_filter: {after dropping low confidence}
          after_cooldown: {after cooldown check}
          classified:
            {action_type}: {count}
          executed:
            {action_type}: {count}
    skipped_targets:
      - {name: {target}, reason: {dirty | recent_commit | invalid_path}}
    summary:
      targets_active: {N}
      targets_skipped: {N}
      total_signals: {N}
      total_actions: {N}
      errors: {N}

🌙 kc-nightwatch 晨報 — {YYYY-MM-DD}

🔧 Auto-fixes ({count}):
• {target}: {summary} — {PR link or "local branch: {branch}"}

📋 Proposals ({count}):
• {target}: {summary} — {PR link or "local branch: {branch}"}

📝 Linear Issues ({count}):
• {target}: {summary} — {issue link}

🧪 E2E Flows ({count}):
• {target}: {summary} — {PR link or "local branch: {branch}"}

⚡ Alerts ({count}):
• {target}: {summary}

⏭️ Skipped: {count} signals ({reasons})

📊 Assessment (per active target):
• {target}: *Strategy:* {pre_assessment first sentence} | *Reflection:* {post_assessment first sentence}
• {target}: *Baselines:* {count} indicators — {improving_count} improving, {degrading_count} degrading

*Strategy:* {pre_assessment first sentence}
*Reflection:* {post_assessment first sentence}
*Baselines:* {count} indicators measured, {improving_count} improving, {degrading_count} degrading

🌙 kc-nightwatch — silent night ({YYYY-MM-DD})

全部 {N} 個 target 被跳過：
• {target}: {reason}
• {target}: {reason}
…

git checkout main

kc-nightwatch: run complete
  Targets scanned: {total}
  Targets active: {active}
  Forge fixes: {count}
  Quick-fixes: {count}
  Proposals: {count}
  Linear issues: {count}
  E2E flows: {count}
  Alerts: {count}
  Skipped signals: {count}
  Duration: {minutes}m