Close ops inventory probe handoff

Updated by fix-consistency on 2026-06-16:
  - update .custodian-brief.md for activity-core

.claude/rules/agents.md

@@ -0,0 +1,20 @@
+## Kaizen Agents
+
+Specialized agent personas available on demand via the state-hub MCP.
+
+**Discover:** `list_kaizen_agents()` — returns all agents with name, description, category
+**Load:** `get_kaizen_agent("tdd-workflow")` — returns full instructions; read and follow them
+
+Common agents:
+
+| Agent | Category | When to use |
+|-------|----------|-------------|
+| `tdd-workflow` | testing | Step-by-step TDD8 workflow for any feature |
+| `code-refactoring` | quality | Code quality analysis and safe refactoring |
+| `test-maintenance` | testing | Diagnose and fix failing tests |
+| `requirements-engineering` | process | Prevent interface/mock mismatches upfront |
+| `keepaTodofile` | process | Maintain TODO.md during work |
+| `project-management` | process | Track status, determine next steps |
+| `datamodel-optimization` | quality | Optimize dataclasses and data structures |
+
+All 17 agents: call `list_kaizen_agents()` for the full list.

.claude/rules/architecture.md

@@ -0,0 +1,8 @@
+## Architecture
+
+<!-- TODO: Describe the key design decisions and component structure.
+     Key modules, data flows, external integrations, state machines, etc. -->
+
+## Quick Reference
+
+`~/state-hub/mcp_server/TOOLS.md` — MCP tool reference

.claude/rules/first-session.md

@@ -0,0 +1,38 @@
+## First Session Protocol
+
+Triggered when `get_domain_summary("custodian")` shows **no workstreams**.
+The project is registered but work has not yet been structured.
+
+**Step 1 — Read, don't write**
+- `~/the-custodian/canon/projects/custodian/project_charter_v0.1.md` — purpose, scope
+- `~/the-custodian/canon/projects/custodian/roadmap_v0.1.md` — planned phases
+- Scan repo root: README, directory structure, existing code or docs
+
+**Step 2 — Survey in-progress work**
+Look for TODOs, open branches, half-finished files. Note done vs. started but incomplete.
+
+**Step 3 — Propose workstreams to Bernd**
+Propose 1–3 workstreams — each a coherent strand, weeks to months, anchored to a
+roadmap phase. **Wait for approval before creating.**
+
+**Step 4 — Create workplan file first, then DB record (ADR-001)**
+```
+workplans/activity-core-WP-NNNN-<slug>.md   ← write this first
+```
+Then register in the hub:
+```
+create_workstream(topic_id="cee7bedf-2b48-46ef-8601-006474f2ad7a", title="...", owner="...", description="...")
+create_task(workstream_id="<id>", title="...", priority="high|medium|low")
+```
+
+**Step 5 — Record the setup**
+```
+add_progress_event(
+    summary="First session: structured custodian into N workstreams, M tasks",
+    event_type="milestone",
+    topic_id="cee7bedf-2b48-46ef-8601-006474f2ad7a",
+    detail={"workstreams": [...], "tasks_created": M}
+)
+```
+
+<!-- Delete or archive this file once past first session -->

.claude/rules/repo-boundary.md

@@ -0,0 +1,8 @@
+## Repo boundary
+
+This repo owns **activity-core** only. It does not own:
+
+<!-- TODO: List what belongs in adjacent repos, e.g.:
+- SSH key management → railiance-infra/
+- State hub code     → state-hub/
+-->

.claude/rules/repo-identity.md

@@ -0,0 +1,5 @@
+**Purpose:** Durable task factory built on Temporal. Manages ActivityDefinitions, schedules recurring workflows via Temporal Schedules, routes events via NATS JetStream, and exposes a FastAPI CRUD surface for the custodian domain.
+
+**Domain:** custodian
+**Repo slug:** activity-core
+**Topic ID:** cee7bedf-2b48-46ef-8601-006474f2ad7a

.claude/rules/session-protocol.md

@@ -0,0 +1,84 @@
+## Session Protocol
+
+State Hub: http://127.0.0.1:8000
+
+**Step 1 — Orient**
+
+Read the offline-safe brief first — it works without a live hub connection:
+```bash
+cat .custodian-brief.md
+```
+Then call the MCP tool for richer cross-domain context when MCP tools are exposed:
+```
+get_domain_summary("custodian")
+```
+If MCP tools are unavailable in the current agent session, use the REST API:
+```bash
+curl -s "http://127.0.0.1:8000/state/summary" | python3 -m json.tool
+```
+If the hub is offline: `cd ~/state-hub && make api`
+
+**Step 2 — Check inbox**
+With MCP tools:
+```
+get_messages(to_agent="activity-core", unread_only=True)
+```
+Mark read with `mark_message_read(message_id)`. Reply or act on coordination
+requests before proceeding.
+
+Without MCP tools:
+```bash
+curl -s "http://127.0.0.1:8000/messages/?to_agent=activity-core&unread_only=true" \
+  | python3 -m json.tool
+curl -s -X PATCH "http://127.0.0.1:8000/messages/<id>/read" \
+  -H "Content-Type: application/json" -d '{}'
+```
+
+**Step 3 — Scan workplans**
+```bash
+ls workplans/
+```
+For each file with `status: ready`, `active`, or `blocked`, note pending
+`todo`/`in_progress` tasks.
+
+**Step 4 — Present brief**
+
+1. **Active workstreams** for `custodian` — title, task counts, blocking decisions
+2. **Pending tasks** from `workplans/` + any `[repo:activity-core]` hub tasks
+3. **Goal guidance** — if `goal_guidance` in summary:
+   - `needs_workplan`: surface as top action — *"Repo goal '{title}' has no workplan yet"*
+   - `alignment_warnings`: flag if active work is not aligned with current goal
+4. **Suggested next action** — highest-priority open item
+5. **SBOM status** — flag if `last_sbom_at` is unset for this repo
+
+If no workstreams: follow First Session Protocol (`first-session.md`).
+
+**During work:** `record_decision()` · `add_progress_event()` · `resolve_decision()`
+
+> State Hub is a *read model*. Bootstrap tools (`create_workstream`, `create_task`)
+> are First Session Protocol only. Work structure belongs in repo files (ADR-001).
+
+**Session close:**
+With MCP tools:
+```
+add_progress_event(summary="...", topic_id="cee7bedf-2b48-46ef-8601-006474f2ad7a", workstream_id="<uuid>")
+```
+Without MCP tools:
+```bash
+curl -s -X POST http://127.0.0.1:8000/progress/ \
+  -H "Content-Type: application/json" \
+  -d '{"topic_id":"cee7bedf-2b48-46ef-8601-006474f2ad7a","workstream_id":"<uuid>","event_type":"note","summary":"what changed","author":"codex"}'
+```
+If workplan files were modified, ensure the local copy is up to date first:
+```bash
+git -C <repo_path> pull --ff-only
+cd ~/state-hub && make fix-consistency REPO=activity-core
+```
+For repos where implementation runs on a remote machine (e.g. CoulombCore),
+use the combined target which pulls before fixing:
+```bash
+cd ~/state-hub && make fix-consistency-remote REPO=activity-core
+```
+**C-15** (DB task ahead of file) is normal in multi-machine workflows — writeback
+will sync the file to match DB.  **C-16** (repo behind remote) blocks all writes
+until you pull — intentional to prevent clobbering remote progress.

.claude/rules/stack-and-commands.md

@@ -0,0 +1,19 @@
+## Stack
+
+<!-- TODO: Fill in language, frameworks, and key dependencies -->
+- **Language:**
+- **Key deps:**
+
+## Dev Commands
+
+```bash
+# TODO: Fill in the standard commands for this repo
+
+# Install dependencies
+
+# Run tests
+
+# Lint / type check
+
+# Build / package (if applicable)
+```

.claude/rules/workplan-convention.md

@@ -0,0 +1,28 @@
+## Workplan Convention (ADR-001)
+
+File location: `workplans/activity-core-WP-NNNN-<slug>.md`
+ID prefix: `ACTIVITY-WP`
+
+Work items originate as files in this repo **before** being registered in the hub.
+
+Canonical workplan/workstream frontmatter statuses are:
+`proposed`, `ready`, `active`, `blocked`, `backlog`, `finished`, `archived`.
+Use `proposed` for a newly drafted plan, `ready` after review against current
+repo state, and `finished` when implementation is complete. `stalled` and
+`needs_review` are derived health labels, not stored statuses.
+
+Closed workplans may be moved to `workplans/archived/` with a completion-date
+prefix: `YYMMDD-activity-core-WP-NNNN-<slug>.md`. The frontmatter id remains
+unchanged; the prefix is only for quick visual reference.
+
+Small opportunistic tasks discovered during another session use **Ad Hoc Tasks**:
+`workplans/ADHOC-YYYY-MM-DD.md`, workstream slug `adhoc-YYYY-MM-DD`, and task ids
+`ADHOC-YYYY-MM-DD-T01`, `T02`, etc. Use adhocs only for low-risk work completed
+directly. Promote anything requiring analysis, design, approval, dependencies, or
+multiple planned phases into a normal workplan.
+
+Ecosystem todos from other agents arrive as `[repo:activity-core]` hub tasks —
+visible at session start. Pick one up by creating the workplan file, then registering
+the workstream.
+
+<!-- Ralph Loop rules and HEUREKA sequence: ~/.claude/CLAUDE.md — do not duplicate here -->

.custodian-brief.md

@@ -2,12 +2,22 @@
 # Custodian Brief — activity-core
 
 **Domain:** custodian  
-**Last synced:** 2026-05-14 22:06 UTC  
+**Last synced:** 2026-06-16 01:49 UTC  
 **State Hub:** http://127.0.0.1:8000 *(adjust if running on a remote machine)*
 
 ## Active Workstreams
 
-*(none — repo may need first-session setup)*
+### Post-triage operational hardening
+Progress: 5/6 done  |  workstream_id: `5646e13a-13af-4724-bca6-3c0d86f96733`
+
+**Open tasks:**
+- ! Three-Run Calibration Feedback  `7cbf0a35`
+
+### Weekly Coding Retrospection schedule (Saturday evenings)
+Progress: 2/3 done  |  workstream_id: `7387fc50-1f2c-471a-9d85-bb085cbd0b63`
+
+**Open tasks:**
+- ! Dry-run verify + enable + docs  `9dcbebe7`
 
 ---
 ## MCP Orientation (when available)

AGENTS.md

@@ -0,0 +1,165 @@
+# activity-core — Agent Instructions
+
+## Repo Identity
+
+**Purpose:** Durable task factory built on Temporal. Manages ActivityDefinitions, schedules recurring workflows via Temporal Schedules, routes events via NATS JetStream, and exposes a FastAPI CRUD surface for the custodian domain.
+
+**Domain:** custodian
+**Repo slug:** activity-core
+**Topic ID:** `cee7bedf-2b48-46ef-8601-006474f2ad7a`
+**Workplan prefix:** `ACTIVITY-WP-`
+
+---
+
+## State Hub Integration
+
+The Custodian State Hub tracks work across all domains. Interact via HTTP REST —
+there is no MCP server for Codex agents.
+
+| Context | URL |
+|---------|-----|
+| Local workstation | `http://127.0.0.1:8000` |
+| Remote via tunnel | `http://127.0.0.1:18000` |
+
+### Orient at session start
+
+```bash
+# Offline brief — works without hub connection
+cat .custodian-brief.md
+
+# Active workstreams for this domain
+curl -s "http://127.0.0.1:8000/workstreams/?topic_id=cee7bedf-2b48-46ef-8601-006474f2ad7a&status=active" \
+  | python3 -m json.tool
+
+# Check inbox
+curl -s "http://127.0.0.1:8000/messages/?to_agent=activity-core&unread_only=true" \
+  | python3 -m json.tool
+```
+
+Mark a message read:
+```bash
+curl -s -X PATCH "http://127.0.0.1:8000/messages/<id>/read" \
+  -H "Content-Type: application/json" -d '{}'
+```
+
+### Log progress (required at session close)
+
+```bash
+curl -s -X POST http://127.0.0.1:8000/progress/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "summary": "what was done",
+    "event_type": "note",
+    "author": "codex",
+    "workstream_id": "<uuid>",
+    "task_id": "<uuid>"
+  }'
+```
+
+Omit `workstream_id` / `task_id` when not applicable.
+
+### Update task status
+
+```bash
+curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
+  -H "Content-Type: application/json" \
+  -d '{"status": "progress"}'
+# values: wait | todo | progress | done | cancel
+```
+
+### Flag a task for human review
+
+```bash
+curl -s -X PATCH "http://127.0.0.1:8000/tasks/<task_id>" \
+  -H "Content-Type: application/json" \
+  -d '{"needs_human": true, "intervention_note": "reason"}'
+```
+
+---
+
+## Session Protocol
+
+**Start:**
+1. `cat .custodian-brief.md` — domain goal and open workstreams (offline-safe)
+2. Check inbox: `GET /messages/?to_agent=activity-core&unread_only=true`; mark read
+3. Scan workplans: `ls workplans/` — note `status: ready`, `active`, or `blocked` files and open tasks
+4. Check blocked tasks: `GET /tasks/?needs_human=true`
+
+**During work:**
+- Update task statuses in workplan files as tasks progress
+- Record significant decisions via `POST /decisions/`
+
+**Close:**
+1. Update workplan file task statuses to reflect progress
+2. Log: `POST /progress/` with a summary of what changed
+3. Note for the custodian operator: after workplan file changes, run from
+   `~/state-hub`:
+   ```bash
+   make fix-consistency REPO=activity-core
+   ```
+   This syncs task status from files into the hub DB.
+
+---
+
+## Workplan Convention (ADR-001)
+
+Work items originate as files in this repo — not in the hub. The hub is a
+read/cache/index layer that rebuilds from files.
+
+**File location:** `workplans/ACTIVITY-WP-NNNN-<slug>.md`
+
+**Archived location:** finished workplans may move to
+`workplans/archived/YYMMDD-ACTIVITY-WP-NNNN-<slug>.md`. The `YYMMDD` prefix is
+the completion/archive date; the frontmatter `id` does not change.
+
+**Ad Hoc Tasks:** small opportunistic fixes discovered during a session use
+`workplans/ADHOC-YYYY-MM-DD.md` with task ids `ADHOC-YYYY-MM-DD-T01`, etc. Use
+this only for low-risk work completed directly; create a normal workplan for
+anything needing analysis, design, approval, dependencies, or multiple phases.
+
+**Frontmatter:**
+
+```yaml
+---
+id: ACTIVITY-WP-NNNN
+type: workplan
+title: "..."
+domain: custodian
+repo: activity-core
+status: proposed | ready | active | blocked | backlog | finished | archived
+owner: codex
+topic_slug: ...
+created: "YYYY-MM-DD"
+updated: "YYYY-MM-DD"
+state_hub_workstream_id: "<uuid>"   # written by fix-consistency — do not edit
+---
+```
+
+Use `proposed` for a new draft, `ready` after review against current repo
+state, and `finished` after implementation. `stalled` and `needs_review` are
+derived health labels, not frontmatter statuses.
+
+**Task block format** (one per `##` section):
+
+```
+## Task Title
+
+` ` `task
+id: ACTIVITY-WP-NNNN-T01
+status: wait | todo | progress | done | cancel
+priority: high | medium | low
+state_hub_task_id: "<uuid>"         # written by fix-consistency — do not edit
+` ` `
+
+Task description text.
+```
+
+Status progression: `todo` → `progress` → `done`; use `wait` for a task
+blocked on external input and `cancel` for intentionally abandoned work.
+Workstream/workplan lifecycle status is separate; frontmatter `blocked` remains
+valid there.
+
+To create a new workplan:
+1. Write the file following the format above
+2. Notify the custodian operator to run `make fix-consistency REPO=activity-core`
+   (or send a message to the hub agent via `POST /messages/`)

CLAUDE.md

@@ -1,205 +1,11 @@
-# CLAUDE.md
+# activity-core — Claude Code Instructions
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+@SCOPE.md
-
+@.claude/rules/repo-identity.md
-## Project Overview
+@.claude/rules/session-protocol.md
-
+@.claude/rules/first-session.md
-`activity-core` is the backbone service for a robust, event-driven "task factory" architecture. The core concept: an `ActivityDefinition` (stored in Postgres) defines a trigger (time-based or event-driven), a context resolver, and task templates. When triggered, a durable workflow evaluates the current context and spawns 0..N `TaskInstance`s.
+@.claude/rules/workplan-convention.md
-
+@.claude/rules/stack-and-commands.md
-**Technology choices (from planning docs in `wiki/`):**
+@.claude/rules/architecture.md
-- **Temporal** (self-hosted) as the orchestration engine — replaces Celery/APScheduler/cron
+@.claude/rules/repo-boundary.md
-- **PostgreSQL** for app data (ActivityDefinitions, run logs, task instances) and Temporal persistence
+@.claude/rules/agents.md
-- **Python SDK** (primary) for Temporal workflows and activities
-
-**Domain model:**
-- `ActivityDefinition` — versioned record with trigger config (cron/event), context sources, task templates
-- `TriggerEvent` — time-based (Temporal Schedule) or external event (broker → Event Router → `client.start_workflow`)
-- `RunActivityWorkflow` — durable Temporal workflow: load definition → resolve context → evaluate rules → spawn tasks → log run
-- `TaskInstance` — child workflow or activity; human-facing tasks persisted to DB
-
-**Planned directory structure (not yet scaffolded):**
-```
-workplans/          # ADR-001: workplan .md files (created before hub registration)
-contrib/            # upstream contribution artifacts (bug-reports/, feature-requests/, extension-points/, upstream-prs/)
-workflows.py        # Temporal workflow definitions
-activities.py       # Temporal activity implementations
-```
-
----
-
-## Custodian State Hub Integration
-
-This project is tracked as the **custodian** domain in the Custodian State Hub.
-Hub topic ID: `cee7bedf-2b48-46ef-8601-006474f2ad7a`
-
-The State Hub runs locally at http://127.0.0.1:8000. The MCP server (`state-hub`)
-exposes tools for reading and writing state without touching the API directly.
-
-### Session Protocol
-
-**On receiving your first message — before writing any response text — execute
-this orientation sequence. Do not greet, do not ask what to do first.**
-
-**Step 1 — Read the offline-safe brief**
-```bash
-cat .custodian-brief.md
-```
-This always works — no MCP, no network required.
-
-**Step 1b — Call the State Hub for richer context** (skip if MCP unreachable)
-```
-get_domain_summary("custodian")   # workstreams, blocking decisions, recent progress, SBOM status
-```
-If the call fails, the API is offline: `cd ~/the-custodian/state-hub && make api`
-
-**Step 1c — Check the agent inbox**
-```
-get_messages(to_agent="activity-core", unread_only=True)
-```
-Mark messages read with `mark_message_read(message_id)`. Act on any coordination requests before proceeding.
-
-**Step 2 — Scan local workplans**
-
-Read every `.md` file under `workplans/`. For each file with `status: active`, extract and note:
-- The workplan title and ID
-- All tasks whose `status` is `todo` or `in_progress`
-
-**Step 3 — Present orientation to the user**
-
-Output a concise brief covering:
-1. **Active workstreams** (from state hub) for the `custodian` domain — title, task counts, any blocking decisions
-2. **Pending tasks for this repo** — from local `workplans/` files plus any state hub tasks with `[repo:activity-core]` in their title
-3. **Goal guidance** — if the summary contains a `goal_guidance` key, act on it:
-   - **`needs_workplan`** entries: for each active repo goal with no linked workstream,
-     surface it as the top suggested action — *"Repo goal '{title}' has no workplan yet.
-     Suggest: create workplans/ACT-WP-NNNN-<slug>.md and register a workstream
-     with repo_goal_id='{goal_id}'"*. Treat this as higher priority than continuing
-     existing work unless Bernd says otherwise.
-   - **`alignment_warnings`** entries: if active workstreams exist but are not linked
-     to the current repo goal, name the most recently active one and note:
-     *"Current work on '{recent_workstream_title}' may not be aligned with the active
-     goal '{active_goal_title}'. Continue unless you hear otherwise — but flag it."*
-4. **Suggested next action** — the highest-priority open item across all sources,
-   with goal alignment taken into account
-5. **SBOM status** — is `last_sbom_at` set for this repo? If not, note it as a gap
-
-If there are no workstreams at all: follow the First Session Protocol below.
-
-**During work:**
-- Use `record_decision()` for any decision that affects direction or dependencies.
-- Use `add_progress_event()` for notable events (milestones, blockers, insights).
-- Use `resolve_decision()` to close a decision once the choice is made.
-
-> **Design boundary:** The State Hub is a *read model*. Two write operations are
-> permanently sanctioned: **Resolving Decisions** and **Suggesting Next Steps**.
-> The bootstrap tools (`create_workstream`, `create_task`, `update_task_status`)
-> are only for First Session Protocol. Formal work structure — workplans, tasks —
-> belongs in the domain repo as files (ADR-001), not managed through the hub alone.
-
-**At the end of every session:**
-- Call `add_progress_event()` with a summary of what was accomplished or decided.
-  Include `topic_id: cee7bedf-2b48-46ef-8601-006474f2ad7a` and the relevant `workstream_id`.
-
----
-
-### Repo Boundary Rule
-
-This agent is responsible for files **in this repo only**.
-
-- **Do not** write files or make commits in any other repository
-- When you identify work for another registered repo (**ecosystem todo**): create a state hub task with `[repo:<slug>]` in the title
-- When you identify work for an upstream repo (**third-party todo**): create a contribution artifact in `contrib/` and register it
-
----
-
-### First Session Protocol
-
-Triggered when `get_state_summary()` shows **no workstreams** for the `custodian` topic.
-
-**Step 1 — Understand the project (read, don't write)**
-- `~/the-custodian/canon/projects/custodian/project_charter_v0.1.md` — purpose, scope
-- `~/the-custodian/canon/projects/custodian/roadmap_v0.1.md` — planned phases
-- `wiki/` — proto-plans from ChatGPT and Grok (architecture reference, not yet compiled into a workplan)
-
-**Step 2 — Survey in-progress work** — look for TODOs, open branches, half-finished files.
-
-**Step 3 — Propose workstreams to Bernd.** Wait for approval before creating.
-
-**Step 4 — Create workplan file first, then DB record (ADR-001):**
-```
-workplans/<DOMAIN>-WP-NNNN-<slug>.md   ← write this first
-```
-Then register in the hub:
-```
-create_workstream(topic_id="cee7bedf-2b48-46ef-8601-006474f2ad7a", title="...", owner="...", description="...")
-create_task(workstream_id="<id>", title="...", priority="high|medium|low")
-```
-
-**Step 5 — Record the setup:**
-```
-add_progress_event(summary="First session: ...", event_type="milestone",
-    topic_id="cee7bedf-2b48-46ef-8601-006474f2ad7a", detail={...})
-```
-
----
-
-### Workplan Convention (ADR-001)
-
-Work items MUST originate as files in this repo before being registered in the hub.
-
-**File location:** `workplans/<ID>-<slug>.md`
-**Frontmatter required:** `id`, `type: workplan`, `domain`, `repo`, `status`,
-`state_hub_workstream_id`, `state_hub_task_id` (per task)
-
----
-
-### Contribution Tracking
-
-Track upstream contributions in `contrib/`:
-```
-contrib/
-  bug-reports/       # br-YYYY-MM-DD--org--repo--slug.md
-  feature-requests/  # fr-YYYY-MM-DD--org--repo--slug.md
-  extension-points/  # EP-custodian-NNN--org--repo--slug.md
-  upstream-prs/      # upr-YYYY-MM-DD--org--repo--slug.md
-```
-Templates: `~/the-custodian/canon/standards/contrib-templates/`
-
-```
-register_contribution(type="br|fr|ep|upr", title="...", target_org="...",
-    target_repo="...", body_path="contrib/...", related_workstream_id="<uuid>")
-```
-
----
-
-### SBOM
-
-After updating dependencies:
-```bash
-cd ~/the-custodian/state-hub
-make ingest-sbom REPO=activity-core SCAN=1 REPO_PATH=$(pwd)
-```
-
----
-
-### Ralph Loop — Workplan-Tied Usage
-
-**Rule: always use `/ralph-workplan` instead of `/ralph-loop` directly.**
-
-```
-/ralph-workplan workplans/<ID>-<slug>.md [--max-iterations 20]
-```
-
-This skill guards against runaway loops:
-1. **Refuses to start** if the workplan `status` is already `done`
-2. **Self-retires** — re-reads the workplan file each iteration; outputs `<promise>HEUREKA</promise>` the moment all tasks are `done`
-3. Always sets `--completion-promise HEUREKA` and a bounded iteration count
-
-**Never** start a ralph loop with a raw static implementation prompt. A static prompt
-has no completion awareness and will loop forever even after the work is done.
-
----
-
-### Quick Reference
-
-`~/the-custodian/state-hub/mcp_server/TOOLS.md` — compact MCP tool reference

Dockerfile

@@ -11,6 +11,9 @@ FROM python:3.12-slim AS runtime
 WORKDIR /app
 COPY --from=builder /app/.venv /app/.venv
 COPY --from=builder /app/src /app/src
+COPY alembic.ini ./
+COPY migrations/ ./migrations/
+COPY scripts/ ./scripts/
 COPY activity-definitions/ ./activity-definitions/
 COPY event-types/ ./event-types/
 COPY tasks/ ./tasks/

Makefile

@@ -49,6 +49,6 @@ start-event-router:  ## Start NATS event router
 # ── Help ──────────────────────────────────────────────────────────────────────
 
 help:  ## Show this help message
-	@grep -E '^[a-zA-Z_-]+:.*?##' $(MAKEFILE_LIST) | \
+	@grep -Eh '^[a-zA-Z_-]+:.*?##' $(MAKEFILE_LIST) | \
 		awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-24s\033[0m %s\n", $$1, $$2}' | \
 		sort

SCOPE.md

@@ -1,7 +1,7 @@
 ---
 domain: capabilities
 repo: activity-core
-updated: "2026-05-14"
+updated: "2026-06-03"
 ---
 
 # SCOPE
@@ -52,11 +52,17 @@ The two evaluation modes:
 - **Context resolution adapters**: repo-scoping (repository capability queries),
   state hub (domain and workstream state), extensible for other sources.
 - **Rule evaluator**: sandboxed AST walker for Python-like boolean expressions
-  over event attributes and resolved context. No `exec()`.
+  over event attributes and resolved context. Rule actions support safe
+  `context.*` / `event.*` interpolation and explicit `for_each` per-item
+  binding. No `exec()`.
 - **Instruction executor**: trusted-field prompt rendering, LLM call via
-  llm-connect, structured output validation, optional curator review queue.
+  llm-connect, structured output validation, optional curator review queue,
+  and deterministic report sinks.
 - **Task emission adapter**: abstraction over issue-core; current transport is
   REST; designed to migrate to NATS subscription without code changes.
+- **Report sinks**: instruction report outputs can be persisted to bounded
+  local working memory and posted as State Hub progress events. These are
+  reporting outputs, not task lifecycle ownership.
 - **Spawn audit log**: every task emission recorded with rule/instruction id,
   triggering event id, model and prompt hash (instructions), issue-core task ref.
 - **Webhook receiver**: HTTP endpoint normalising inbound Gitea/GitHub webhook
@@ -111,16 +117,57 @@ The two evaluation modes:
 
 ## Current State
 
-- **Status**: active — WP-0001 (Foundation) and WP-0002 (Triggers & Ops) complete.
+- **Status**: active production-backed service. Foundation, triggers/ops,
-- **Implementation**: core is functional. `RunActivityWorkflow`, `TaskExecutorWorkflow`
+  event bridge, Railiance deployment, and the production service workplans are
-  (stub), PostgreSQL schema (activity_definitions, activity_runs, task_instances),
+  complete. The stale March WP-0002 handoff note has been reconciled and
-  Temporal Schedules (cron), NATS Event Router, FastAPI admin API, Prometheus
+  archived.
-  metrics, and operational runbook are all implemented.
+- **Implementation**: core is functional. `RunActivityWorkflow`,
-- **Next**: WP-0003 — event type registry, rule/instruction model, task emission
+  `TaskExecutorWorkflow` (stub), PostgreSQL schema, Temporal Schedules, NATS
-  adapter, webhook receiver, one-off `scheduled` trigger type, INTENT.md and
+  Event Router, FastAPI admin API, Prometheus metrics, event type registry,
-  SCOPE.md rewrite (this file). Architecture established in ACT-ADR-001/002/003.
+  markdown ActivityDefinition parser/sync, rule evaluator, instruction
-- **Stability**: core workflow is stable; the rule/instruction layer and registry
+  executor, context resolvers, issue sink, report sinks, Kubernetes deployment,
-  are not yet implemented.
+  and operational runbook are all implemented.
+- **Operational proof**: the daily State Hub WSJF triage cutover has completed
+  far enough that activity-core is now the trusted scheduled substrate for the
+  routine report. Recent hardening fixed the State Hub SBOM resolver contract,
+  made slow LLM activity timeouts configurable, and added safe rule action
+  interpolation plus explicit `for_each` binding for per-repo SBOM staleness
+  tasks.
+- **Stability**: construction risk has shifted to operational hardening risk.
+  The full test suite passed on 2026-06-03 (`125 passed, 1 skipped`). The
+  remaining work is mostly observability, status-canon adaptation, contract
+  documentation, and broader production adoption rather than first
+  implementation.
+- **Next**: `ACTIVITY-WP-0006` — post-triage operational hardening and scope
+  alignment.
+
+---
+
+## Assessment Against Intent
+
+activity-core now matches the core intent: it answers **when** coordination
+work should happen, **what** work should be created from current org context,
+and **where** each work item should land. The daily WSJF triage is the clearest
+judgement-oriented proof point; weekly SBOM staleness is the clearest
+deterministic-rule proof point.
+
+The governing boundary still matters. activity-core should keep owning trigger
+durability, context resolution, rule/instruction evaluation, report/task
+emission, and spawn/report audit. It should not become the task lifecycle
+database, the project planner, or a general execution worker. The local
+`TaskExecutorWorkflow` remains a stub and should stay that way unless a future
+workplan explicitly rehomes execution responsibility.
+
+One boundary nuance is now explicit: activity-core may post State Hub progress
+events as a configured report sink. That is acceptable because it records the
+result of an activity-core activation; it is not ownership of State Hub state,
+task lifecycle, or workstream planning.
+
+The main drift risk is convenience creep: adding direct task tracking,
+project-phase state, or bespoke operational scripts because the Temporal
+substrate is already nearby. Future work should prefer declarative
+ActivityDefinitions, bounded context resolvers, and outbound adapters over
+new one-off control paths.
 
 ---
 
@@ -130,20 +177,19 @@ The two evaluation modes:
 [NATS JetStream]  ←  publishers: state hub, Gitea webhooks, Temporal signals, cron
        ↓
 [activity-core]   ←  event type registry, rule evaluator, instruction executor
-       ↓
+[activity-core]   →  [issue-core]  →  [repos/services]
-[issue-core]      ←  task lifecycle, assignment, tracking (Gitea / SQLite / GitHub)
+[activity-core]   →  [report sinks]
-       ↓
-[repos/services]  ←  execution: actual code changes, scans, operations
 ```
 
 - **Upstream**: NATS (event bus), Temporal (durable workflow engine), PostgreSQL
   (definitions and audit log), repo-scoping (context adapter), state hub (context
   adapter and event publisher).
-- **Downstream**: issue-core (task management). Agents and humans pick up tasks
+- **Downstream**: issue-core (task management) and configured report sinks.
-  from issue-core and do the actual work.
+  Agents and humans pick up tasks from issue-core and do the actual work.
 - **Coordinates with**: the state hub delegates maintenance automations to
-  activity-core by publishing lifecycle events; activity-core never writes to
+  activity-core by publishing lifecycle events or by being resolved as context.
-  the state hub directly.
+  activity-core may post progress events as report outputs, but it does not own
+  State Hub task/workstream state.
 
 ---
 
@@ -203,8 +249,7 @@ The two evaluation modes:
   `src/activity_core/event_router.py` (NATS → Temporal),
   `src/activity_core/schedule_manager.py` (Temporal Schedules),
   `src/activity_core/api.py` (FastAPI admin).
-- Definition files (WP-0003): `event-types/` and `activity-definitions/`
+- Definition files: `event-types/`, `activity-definitions/`, and `tasks/`.
-  (not yet created — coming in WP-0003).
 - Dev environment: `docker-compose.dev.yml` (Temporal + PostgreSQL + NATS).
 - Entry points: `uv run python -m activity_core.worker` (Temporal worker),
   `uv run uvicorn activity_core.api:app --port 8010` (admin API).

activity-definitions/weekly-coding-retro.md

@@ -0,0 +1,48 @@
+---
+id: weekly-coding-retro
+name: Weekly Coding Retrospection
+enabled: false   # flip to true once the coding_retro resolver + session-memory publish (AGENTIC-WP-0010) are verified
+owner: custodian-agent
+governance: custodian
+status: proposed
+trigger:
+  type: cron
+  cron_expression: "0 19 * * 6"   # Saturday 19:00
+  timezone: Europe/Berlin
+  misfire_policy: skip
+context_sources:
+  - type: state-hub
+    query: coding_retro
+    params:
+      window_days: 7
+      limit: 100
+    bind_to: context.retro
+# The coding_retro resolver returns the most recent event_type=coding_retro read
+# model published to the hub by helix_forge session-memory (AGENTIC-WP-0010).
+# Its detail.suggestions[] are already ranked (impact x frequency, cross-flavor
+# first) and capped at 3 per repo, so the rule below just routes them.
+---
+
+# Weekly Coding Retrospection
+
+Runs every Saturday 19:00 Berlin time. Reads the previous week's coding-session
+analysis (published to the hub by helix_forge session-memory) and opens one
+improvement suggestion per relevant repo — the three most promising, already
+ranked upstream.
+
+```rule
+id: propose-weekly-improvements
+for_each: context.retro.suggestions
+bind_as: s
+condition: 'context.s.score > 0'
+action:
+  task_template: context.s.title
+  description: context.s.recommendation
+  target_repo: context.s.repo
+  priority: context.s.priority
+  labels: ["coding-retro", "improvement", "automated"]
+```
+
+Each suggestion carries `repo`, `title`, `recommendation`, `priority`, and
+`score`. The upstream retro caps the list at three per repo, so this emits at most
+three improvement tasks per relevant repository per week.

activity-definitions/weekly-sbom-staleness.md

@@ -16,6 +16,9 @@ context_sources:
     params:
       repos: all
     bind_to: context.repos
+# Resolver returns a summary keyed off the worst repo so the rule expression
+# below can match without comprehensions (the sandboxed evaluator does not
+# support them). See _repo_sbom_status in context_resolvers/state_hub.py.
 ---
 
 # Weekly SBOM Staleness Check
@@ -25,10 +28,17 @@ SBOM staleness and flags any repository whose SBOM is older than 30 days.
 
 ```rule
 id: flag-stale-sbom
-condition: 'context.repos.sbom_age_days > 30'
+for_each: context.repos.repos
+bind_as: repo
+condition: 'context.repo.sbom_age_days > 30'
 action:
-  task_template: tasks/sbom-rescan.md
+  task_template: Run SBOM rescan for {context.repo.repo_slug}
-  target_repo: context.repos.repo_slug
+  target_repo: context.repo.repo_slug
   priority: medium
   labels: ["sbom", "security", "automated"]
 ```
+
+The bulk resolver exposes the per-repo entries under `context.repos.repos`.
+The rule uses explicit `for_each` binding so the workflow evaluates the
+condition once per repository and emits one task per stale repo. Action fields
+may reference the bound item with `context.repo.*`.

docker-compose.railiance.yml

@@ -29,14 +29,16 @@ services:
       POSTGRES_USER: temporal
       POSTGRES_PWD: temporal
       POSTGRES_SEEDS: temporal-db
-      DYNAMIC_CONFIG_FILE_PATH: /etc/temporal/dynamicconfig.yaml
+      DYNAMIC_CONFIG_FILE_PATH: config/dynamicconfig/development-sql.yaml
       ENABLE_ES: "false"
       VISIBILITY_DBNAME: temporal_visibility
       TEMPORAL_ADDRESS: temporal:7233
+    volumes:
+      - ./dynamicconfig:/etc/temporal/config/dynamicconfig
     networks:
       - actcore-net
     healthcheck:
-      test: ["CMD-SHELL", "tctl --address temporal:7233 cluster health 2>&1 | grep -q SERVING"]
+      test: ["CMD", "temporal", "operator", "cluster", "health", "--address", "temporal:7233"]
       interval: 10s
       timeout: 10s
       retries: 20
@@ -59,15 +61,16 @@ services:
   # ── NATS with JetStream ───────────────────────────────────────────────────────
   nats:
     image: nats:2.10-alpine
-    command: ["-js", "-sd", "/data"]
+    command: ["-js", "-sd", "/data", "-m", "8222"]
     volumes:
       - nats-data:/data
     ports:
       - "4222:4222"
+      - "8222:8222"
     networks:
       - actcore-net
     healthcheck:
-      test: ["CMD-SHELL", "nats-server --help > /dev/null 2>&1 || wget -q -O- http://localhost:8222/healthz | grep -q ok"]
+      test: ["CMD-SHELL", "wget -qO- http://localhost:8222/healthz | grep -q ok"]
       interval: 5s
       timeout: 5s
       retries: 10
@@ -141,7 +144,7 @@ services:
       - actcore-net
     restart: unless-stopped
     healthcheck:
-      test: ["CMD-SHELL", "curl -sf http://localhost:8010/health"]
+      test: ["CMD", "python", "-c", "import urllib.request,sys; r=urllib.request.urlopen('http://localhost:8010/health'); sys.exit(0 if r.status==200 else 1)"]
       interval: 10s
       timeout: 5s
       retries: 5

docs/adr/adr-003-rule-instruction-model.md

@@ -101,17 +101,58 @@ A Rule's action block specifies:
 
 ```yaml
 action:
-  task_template: tasks/{template-slug}.md   # required
+  task_template: "Run SBOM rescan for {context.repo.repo_slug}"
-  target_repo: event.attributes.repo_slug    # expression — attribute access only
+  target_repo: context.repo.repo_slug
-  priority: high                             # high | medium | low | literal
+  priority: medium
-  labels: ["onboarding", "security"]        # literal list
+  labels: ["sbom", "security", "{context.repo.repo_slug}"]
-  due_in_days: 7                             # optional, integer literal
+  due_in_days: 7
 ```
 
-`target_repo` and similar fields accept simple attribute access expressions
+`action.task_template` is the emitted task title template. It is not a path to a
-(no boolean logic — just path traversal). This allows dynamic routing to the
+repo-local file. Older design notes and the legacy `tasks/*.md` directory use
-correct issue-core instance without arbitrary expression evaluation in action
+"task template" for materialized task-body templates; that is a separate legacy
-fields.
+surface. To avoid surprise, new rule actions should treat `task_template` as
+`title_template` semantics until the field can be renamed in a schema-breaking
+revision.
+
+Action fields accept two deterministic rendering forms:
+
+- Whole-field paths: if the whole string is a path like
+  `context.repo.repo_slug` or `event.attributes.repo_slug`, the rendered value
+  keeps the original scalar/list/object shape from that path. This is the
+  correct form for `target_repo` and other fields that should not become prose.
+- Scalar placeholders: strings may include `{context.foo}` or `{event.foo}`
+  placeholders. Each placeholder must resolve to a scalar. Lists and objects are
+  rejected rather than stringified, which prevents accidental JSON blobs or
+  untrusted text from being embedded into task titles.
+
+Unsafe action cases are rejected:
+
+- Any action path outside `context.*` or `event.*`.
+- Any path containing calls, indexing, arithmetic, filters, or boolean logic.
+- Placeholder values that resolve to lists or objects.
+- `for_each` values that are not a whole-field `context.*` or `event.*` path to
+  a list.
+- `bind_as` names that are not simple identifiers.
+
+Per-item rule expansion is explicit:
+
+```yaml
+for_each: context.repos.repos
+bind_as: repo
+condition: 'context.repo.sbom_age_days > 30'
+action:
+  task_template: Run SBOM rescan for {context.repo.repo_slug}
+  target_repo: context.repo.repo_slug
+  priority: medium
+  labels: ["sbom", "security", "automated"]
+```
+
+The weekly SBOM staleness definition is the canonical pattern. The State Hub
+bulk resolver exposes all repository entries at `context.repos.repos`, the rule
+binds each item as `context.repo`, and the strict staleness definition is
+`context.repo.sbom_age_days > 30`. Thirty days exactly is not stale; thirty-one
+days is stale.
 
 #### Evaluation semantics
 

docs/issue-core-emission-boundary.md

@@ -0,0 +1,70 @@
+# Issue-Core Emission Boundary
+
+activity-core owns the decision to spawn a task and the audit trail that says
+why it spawned. It does not own downstream task lifecycle state after emission.
+
+## Current authoritative endpoint
+
+The current authoritative boundary is the issue-core REST API:
+
+```text
+POST {ISSUE_CORE_URL}/issues/
+```
+
+`IssueCoreRestSink` sends this payload:
+
+```json
+{
+  "title": "Run SBOM rescan for activity-core",
+  "description": "",
+  "target_repo": "activity-core",
+  "priority": "medium",
+  "labels": ["sbom", "security", "automated"],
+  "due_in_days": null,
+  "source_type": "rule",
+  "source_id": "flag-stale-sbom",
+  "triggering_event_id": "event-or-schedule-key",
+  "activity_definition_id": "activity-definition-uuid"
+}
+```
+
+The expected response contains `issue_id` and may include `issue_url` and
+`backend`. activity-core stores only the returned task reference in
+`task_spawn_log`; issue-core remains authoritative for task status, assignment,
+comments, closure, and cancellation.
+
+## REST versus NATS
+
+Keep REST as the active emission contract until issue-core publishes and owns a
+durable NATS consumer for task-creation commands. NATS is still appropriate for
+event intake into activity-core, but task creation needs an acknowledged,
+idempotent command boundary. A future NATS sink must return or later correlate a
+task reference before it can replace `IssueCoreRestSink`.
+
+## Safe operating modes
+
+- `ISSUE_SINK_TYPE=null`: dry-run/audit mode. Task specs are rendered and the
+  workflow records synthetic `null-*` references. This is the current Railiance
+  production setting.
+- `ISSUE_SINK_TYPE=rest`: live task creation. Sink failures raise out of
+  `emit_tasks`, so Temporal retries and the workflow history make failures
+  visible.
+
+Weekly SBOM staleness is safe to evaluate in dry-run mode because the rule
+contract is deterministic and tested. Do not enable it against the real REST sink
+until issue-core credentials, endpoint reachability, and duplicate-handling are
+verified in the target environment.
+
+## Verification
+
+Local contract tests cover the rendered weekly SBOM task path and the REST
+payload shape:
+
+```bash
+uv run pytest tests/test_integration_event_bridge.py tests/test_issue_sink.py
+```
+
+For a live environment, run with `ISSUE_SINK_TYPE=null` first and confirm
+`task_spawn_log` contains the expected source id, condition, triggering event id,
+and synthetic task reference. Then switch to `ISSUE_SINK_TYPE=rest` only after a
+single known-safe rule match creates one issue-core task with the same fields.

docs/runbook.md

@@ -129,6 +129,44 @@ This reconciles all Temporal Schedules with the `activity_definitions` table:
 - Creates paused schedules for disabled cron definitions
 - Deletes orphaned schedules with no matching DB row
 
+After adding or changing a recurring ActivityDefinition or workflow activity
+wiring, run a smoke schedule before trusting the next real fire:
+
+```bash
+ACTCORE_DB_URL=postgresql+asyncpg://actcore:actcore@localhost:5433/actcore \
+TEMPORAL_HOST=localhost:7233 \
+  uv run python scripts/smoke_test_schedule.py \
+    --activity-id <activity-definition-uuid> \
+    --recreate-recurring
+```
+
+The smoke command deletes and recreates the recurring Temporal Schedule when
+`--recreate-recurring` is set, creates a distinct one-shot smoke Schedule one
+minute in the future, waits for the smoke workflow to complete, and exits
+non-zero if the workflow fails or times out. Use this after worker deployments
+that add workflow imports or new activities; it catches stale-worker and missing
+activity registration issues before the next scheduled run.
+
+---
+
+## Weekly maintenance definitions
+
+`weekly-sbom-staleness` is the canonical rule-only weekly maintenance schedule.
+It runs Mondays at 09:00 Europe/Berlin, resolves State Hub SBOM status for all
+repos, and emits one automated task per stale repo through explicit
+`for_each: context.repos.repos`.
+
+`weekly-coding-retro` follows the same cron -> context resolver -> per-repo task
+pattern for coding-session retrospection. It runs Saturdays at 19:00
+Europe/Berlin and resolves the latest State Hub `/progress/` item with
+`event_type=coding_retro` into `context.retro.suggestions`. Each positive-score
+suggestion emits one task to `context.s.repo` with labels
+`coding-retro`, `improvement`, and `automated`.
+
+Keep `weekly-coding-retro` disabled until Helix Forge publishes the
+`coding_retro` read model and a smoke run confirms the resolver returns a
+non-empty suggestion set with no duplicate target tasks on re-run.
+
 ---
 
 ## Temporal UI — filtering by activity
@@ -147,6 +185,55 @@ docker exec temporal-admin-tools temporal workflow list \
 
 ---
 
+## Daily State Hub WSJF triage verification
+
+Use this when answering: "did today's daily triage run happen?"
+
+Set the ActivityDefinition id when known. If it is not known, pass the
+definition name used in the environment and let the live helper resolve it from
+Postgres.
+
+```bash
+export DAILY_TRIAGE_ACTIVITY_ID=<daily-triage-activity-definition-uuid>
+
+# Dry-run checklist; safe from any shell because it only prints checks.
+uv run python scripts/verify_daily_triage.py \
+  --activity-id "$DAILY_TRIAGE_ACTIVITY_ID" \
+  --date "$(date -u +%F)"
+
+# Live check from a shell with Temporal, DB, State Hub, and working-memory access.
+ACTCORE_DB_URL=postgresql+asyncpg://actcore:actcore@localhost:5433/actcore \
+TEMPORAL_HOST=localhost:7233 \
+STATE_HUB_URL=http://127.0.0.1:8000 \
+  uv run python scripts/verify_daily_triage.py \
+    --activity-id "$DAILY_TRIAGE_ACTIVITY_ID" \
+    --working-memory-dir /home/worsch/the-custodian/memory/working \
+    --live
+```
+
+The verification is complete when all of these agree:
+
+- Temporal schedule `activity-schedule-$DAILY_TRIAGE_ACTIVITY_ID` exists, is not
+  paused, and uses the `skip` overlap policy.
+- The latest workflow found with `ActivityId="$DAILY_TRIAGE_ACTIVITY_ID"` either
+  completed or is visibly retrying a failed activity in history.
+- `activity_runs` has a row for the daily triage ActivityDefinition with today's
+  `scheduled_for` or `fired_at` date.
+- State Hub `/progress/` contains a `daily_triage` event whose detail includes
+  the same `activity_core_run_id` and its `output_validated` flag.
+- The working-memory sink wrote `daily-triage-YYYY-MM-DD-<run>.md` and its
+  frontmatter contains the same `activity_core_run_id` and validation metadata.
+- The ActivityDefinition's instruction model, token budget, and sink timeouts fit
+  under `ACTIVITY_TIMEOUT_SECONDS` (default 900 seconds). Temporal retries each
+  activity up to 10 attempts, so a slow LLM or sink failure should show as
+  workflow retry history rather than a silent missing report.
+
+Expected missed-run behavior: the daily triage definition should use
+`misfire_policy: skip`. Planned downtime does not catch up missed daily reports;
+the next scheduled fire is the next authoritative run.
+
+---
+
 ## Scale-out
 
 ### Multiple worker replicas
@@ -204,6 +291,46 @@ Set the environment variable before running the worker.
 2. `curl http://localhost:9090/metrics` should return Temporal SDK metrics.
 3. If port 9090 conflicts with Prometheus server, set `PROMETHEUS_BIND_ADDR=0.0.0.0:9091`.
 
+### Production alerting and failure modes
+
+Kubernetes health expectations:
+
+```bash
+kubectl -n activity-core get deploy actcore-worker actcore-api actcore-event-router
+kubectl -n activity-core get pods -l app.kubernetes.io/part-of=activity-core
+kubectl -n activity-core port-forward svc/actcore-worker-metrics 9090:9090
+curl -sf http://127.0.0.1:9090/metrics
+```
+
+Page an operator when:
+
+- `actcore-worker` has no ready pod, cannot connect to Temporal, or cannot reach
+  Postgres.
+- The daily triage schedule is missing or paused outside an approved maintenance
+  window.
+- The expected daily triage run is absent from Temporal and `activity_runs`
+  after the retry window.
+- Both State Hub progress and working-memory report sinks are missing for a
+  completed run.
+- Report sink or task emission failures repeat across Temporal retries.
+
+Leave a State Hub progress note, but do not page, when:
+
+- A planned outage caused one skipped run and the schedule is healthy again.
+- A sink idempotency check reports `exists` for the expected run id.
+- An instruction report has `output_validated=false` but still emitted a
+  validation-failure note preserving partial model output for review.
+- The report completed but calibration feedback says the recommendations were
+  noisy, too long, or under-sensitive.
+
+Handle in the next operator session:
+
+- Prompt/schema tuning, loose-end sensitivity, and stale-but-parked work
+  calibration.
+- Non-urgent schedule jitter or timeout adjustments.
+- Moving a task sink from `ISSUE_SINK_TYPE=null` to the real issue-core endpoint
+  after a dry-run contract check has passed.
+
 ### DB migration drift
 ```bash
 uv run alembic current    # show current revision

event-types/ops-access-path-checked.md

@@ -0,0 +1,55 @@
+---
+type_id: ops-access-path-checked
+version: "1.0"
+publisher: activity-core
+governance: publisher-declared
+status: active
+---
+
+# ops-access-path-checked
+
+## Intent
+
+Published when an inventory access path is checked or deliberately skipped.
+The first activity-core implementation records non-HTTP/k8s/ssh/tunnel paths as
+`skipped` / unsupported rather than executing commands.
+
+## Attributes
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| activity_core_run_id | uuid | yes | UUID of the activity-core run that produced this evidence. |
+| idempotency_key | string | yes | Stable key for deduplicating this access-path evidence. |
+| service_id | string | yes | Stable service id from the inventory. |
+| access_path_id | string | yes | Stable or derived access path id. |
+| access_path_type | string | yes | Declared access path type such as `http`, `k8s`, `ssh`, or `tunnel`. |
+| declared_status | string | no | Status declared in the inventory. |
+| observed_status | string | yes | One of `ok`, `degraded`, `down`, or `skipped`. |
+| reason | string | no | Compact non-secret reason such as `unsupported_access_path_type`. |
+| observed_at | datetime | yes | UTC time when the evidence was generated. |
+
+## Example Payload
+
+```json
+{
+  "type": "ops-access-path-checked",
+  "version": "1.0",
+  "publisher": "activity-core",
+  "attributes": {
+    "activity_core_run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+    "idempotency_key": "12345678:gitea:gitea-access-1:ops-access-path-checked",
+    "service_id": "gitea",
+    "access_path_id": "gitea-access-1",
+    "access_path_type": "k8s",
+    "declared_status": "unknown",
+    "observed_status": "skipped",
+    "reason": "unsupported_access_path_type",
+    "observed_at": "2026-06-05T10:15:01Z"
+  }
+}
+```
+
+## Safety
+
+Do not include secrets, authorization headers, cookies, tokens, raw response
+bodies, command output, private key material, or unredacted URL query strings.

event-types/ops-backup-verified.md

@@ -0,0 +1,54 @@
+---
+type_id: ops-backup-verified
+version: "1.0"
+publisher: activity-core
+governance: publisher-declared
+status: active
+---
+
+# ops-backup-verified
+
+## Intent
+
+Published when backup or restore evidence for a service backing store has been
+verified from non-secret metadata. The initial probe runner may emit `skipped`
+until backup evidence is available.
+
+## Attributes
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| activity_core_run_id | uuid | yes | UUID of the activity-core run that produced this evidence. |
+| idempotency_key | string | yes | Stable key for deduplicating this backup evidence. |
+| service_id | string | yes | Stable service id from the inventory. |
+| backing_store_ref | string | yes | Non-secret backing store reference from the inventory. |
+| backup_evidence_ref | string | no | Non-secret document, progress, or artifact reference. |
+| restore_verified | boolean | no | Whether restore evidence has been verified. |
+| observed_status | string | yes | One of `ok`, `degraded`, `down`, or `skipped`. |
+| reason | string | no | Compact non-secret reason for non-OK status. |
+| observed_at | datetime | yes | UTC time when the evidence was generated. |
+
+## Example Payload
+
+```json
+{
+  "type": "ops-backup-verified",
+  "version": "1.0",
+  "publisher": "activity-core",
+  "attributes": {
+    "activity_core_run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+    "idempotency_key": "12345678:gitea:database:gitea-db:ops-backup-verified",
+    "service_id": "gitea",
+    "backing_store_ref": "database:gitea-db",
+    "restore_verified": false,
+    "observed_status": "skipped",
+    "reason": "backup_probe_not_implemented",
+    "observed_at": "2026-06-05T10:15:01Z"
+  }
+}
+```
+
+## Safety
+
+Do not include secrets, authorization headers, cookies, tokens, raw response
+bodies, command output, private key material, or unredacted URL query strings.

event-types/ops-endpoint-verified.md

@@ -0,0 +1,63 @@
+---
+type_id: ops-endpoint-verified
+version: "1.0"
+publisher: activity-core
+governance: publisher-declared
+status: active
+---
+
+# ops-endpoint-verified
+
+## Intent
+
+Published when activity-core checks an inventory endpoint and compares the
+non-secret response metadata to the declared expected status and signal.
+
+## Attributes
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| activity_core_run_id | uuid | yes | UUID of the activity-core run that produced this evidence. |
+| idempotency_key | string | yes | Stable key for deduplicating this endpoint evidence. |
+| service_id | string | yes | Stable service id from the inventory. |
+| endpoint_id | string | yes | Stable endpoint id from the inventory. |
+| endpoint_type | string | yes | Endpoint type, usually `http` or `https` for the first implementation. |
+| endpoint_url | string | yes | Sanitized URL without credentials, query string, or fragment. |
+| expected_status | integer | no | Declared expected HTTP status. |
+| status_code | integer | no | Observed HTTP status code, if a response was received. |
+| matched_expected_status | boolean | no | Whether the observed status matched the declaration. |
+| matched_expected_signal | boolean | no | Whether the expected signal was found without storing the response body. |
+| observed_status | string | yes | One of `ok`, `degraded`, `down`, or `skipped`. |
+| reason | string | no | Compact non-secret reason such as `expected_status_mismatch`. |
+| observed_at | datetime | yes | UTC time when the endpoint evidence was generated. |
+| widget_ref | string | no | Optional ops widget reference from the inventory. |
+
+## Example Payload
+
+```json
+{
+  "type": "ops-endpoint-verified",
+  "version": "1.0",
+  "publisher": "activity-core",
+  "attributes": {
+    "activity_core_run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+    "idempotency_key": "12345678:gitea:gitea-oci-registry:ops-endpoint-verified",
+    "service_id": "gitea",
+    "endpoint_id": "gitea-oci-registry",
+    "endpoint_type": "https",
+    "endpoint_url": "https://gitea.coulomb.social/v2/",
+    "expected_status": 401,
+    "status_code": 401,
+    "matched_expected_status": true,
+    "matched_expected_signal": true,
+    "observed_status": "ok",
+    "observed_at": "2026-06-05T10:15:01Z",
+    "widget_ref": "ops:endpoint:gitea-registry"
+  }
+}
+```
+
+## Safety
+
+Do not include secrets, authorization headers, cookies, tokens, raw response
+bodies, command output, private key material, or unredacted URL query strings.

event-types/ops-inventory-drift.md

@@ -0,0 +1,56 @@
+---
+type_id: ops-inventory-drift
+version: "1.0"
+publisher: activity-core
+governance: publisher-declared
+status: active
+---
+
+# ops-inventory-drift
+
+## Intent
+
+Published when observed non-secret runtime evidence differs from the declared
+ops inventory and the difference should be visible to ops-hub or operators.
+
+## Attributes
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| activity_core_run_id | uuid | yes | UUID of the activity-core run that produced this evidence. |
+| idempotency_key | string | yes | Stable key for deduplicating this drift evidence. |
+| service_id | string | yes | Stable service id from the inventory. |
+| inventory_object_id | string | no | Endpoint, access path, backing store, or runtime object id. |
+| drift_kind | string | yes | Compact drift category such as `missing_endpoint` or `status_mismatch`. |
+| declared_summary | string | no | Bounded non-secret summary of the declared value. |
+| observed_summary | string | no | Bounded non-secret summary of the observed value. |
+| observed_status | string | yes | Usually `degraded` for drift evidence. |
+| reason | string | no | Compact non-secret reason for the drift event. |
+| observed_at | datetime | yes | UTC time when the drift evidence was generated. |
+
+## Example Payload
+
+```json
+{
+  "type": "ops-inventory-drift",
+  "version": "1.0",
+  "publisher": "activity-core",
+  "attributes": {
+    "activity_core_run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+    "idempotency_key": "12345678:gitea:gitea-oci-registry:ops-inventory-drift",
+    "service_id": "gitea",
+    "inventory_object_id": "gitea-oci-registry",
+    "drift_kind": "status_mismatch",
+    "declared_summary": "expected_status=401",
+    "observed_summary": "status_code=200",
+    "observed_status": "degraded",
+    "reason": "expected_status_mismatch",
+    "observed_at": "2026-06-05T10:15:01Z"
+  }
+}
+```
+
+## Safety
+
+Do not include secrets, authorization headers, cookies, tokens, raw response
+bodies, command output, private key material, or unredacted URL query strings.

event-types/ops-service-observed.md

@@ -0,0 +1,53 @@
+---
+type_id: ops-service-observed
+version: "1.0"
+publisher: activity-core
+governance: publisher-declared
+status: active
+---
+
+# ops-service-observed
+
+## Intent
+
+Published when activity-core observes a service from the declared ops inventory
+and records compact non-secret runtime evidence.
+
+## Attributes
+
+| Name | Type | Required | Description |
+|---|---|---|---|
+| activity_core_run_id | uuid | yes | UUID of the activity-core run that produced this evidence. |
+| idempotency_key | string | yes | Stable key for deduplicating this evidence event. |
+| service_id | string | yes | Stable service id from `ops/service-inventory.yml`. |
+| service_name | string | no | Human-readable service name. |
+| environment | string | no | Inventory environment id. |
+| lifecycle_state | string | no | Declared service lifecycle state. |
+| observed_status | string | yes | One of `ok`, `degraded`, `down`, or `skipped`. |
+| observed_at | datetime | yes | UTC time when the evidence was generated. |
+| reason | string | no | Compact non-secret reason for non-OK status. |
+
+## Example Payload
+
+```json
+{
+  "type": "ops-service-observed",
+  "version": "1.0",
+  "publisher": "activity-core",
+  "attributes": {
+    "activity_core_run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+    "idempotency_key": "12345678:state-hub:ops-service-observed",
+    "service_id": "state-hub",
+    "service_name": "State Hub",
+    "environment": "local",
+    "lifecycle_state": "observed",
+    "observed_status": "ok",
+    "observed_at": "2026-06-05T10:15:01Z"
+  }
+}
+```
+
+## Safety
+
+Do not include secrets, authorization headers, cookies, tokens, raw response
+bodies, command output, private key material, or unredacted URL query strings.

k8s/railiance/00-namespace.yaml

@@ -0,0 +1,7 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: activity-core
+  labels:
+    app.kubernetes.io/name: activity-core
+    app.kubernetes.io/part-of: custodian

k8s/railiance/10-infrastructure.yaml

@@ -0,0 +1,364 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-app-db
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-app-db
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-app-db
+  ports:
+    - name: postgres
+      port: 5432
+      targetPort: postgres
+---
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: actcore-app-db
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-app-db
+    app.kubernetes.io/part-of: activity-core
+spec:
+  serviceName: actcore-app-db
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-app-db
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-app-db
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: postgres
+          image: postgres:16
+          imagePullPolicy: IfNotPresent
+          ports:
+            - name: postgres
+              containerPort: 5432
+          env:
+            - name: POSTGRES_USER
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-app-db-secret
+                  key: username
+            - name: POSTGRES_PASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-app-db-secret
+                  key: password
+            - name: POSTGRES_DB
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-app-db-secret
+                  key: database
+          readinessProbe:
+            exec:
+              command: ["pg_isready", "-U", "actcore"]
+            initialDelaySeconds: 5
+            periodSeconds: 10
+          livenessProbe:
+            exec:
+              command: ["pg_isready", "-U", "actcore"]
+            initialDelaySeconds: 30
+            periodSeconds: 20
+          volumeMounts:
+            - name: data
+              mountPath: /var/lib/postgresql/data
+  volumeClaimTemplates:
+    - metadata:
+        name: data
+      spec:
+        accessModes: ["ReadWriteOnce"]
+        resources:
+          requests:
+            storage: 5Gi
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-temporal-db
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-temporal-db
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-temporal-db
+  ports:
+    - name: postgres
+      port: 5432
+      targetPort: postgres
+---
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: actcore-temporal-db
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-temporal-db
+    app.kubernetes.io/part-of: activity-core
+spec:
+  serviceName: actcore-temporal-db
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-temporal-db
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-temporal-db
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: postgres
+          image: postgres:16
+          imagePullPolicy: IfNotPresent
+          ports:
+            - name: postgres
+              containerPort: 5432
+          env:
+            - name: POSTGRES_USER
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-temporal-db-secret
+                  key: username
+            - name: POSTGRES_PASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-temporal-db-secret
+                  key: password
+            - name: POSTGRES_DB
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-temporal-db-secret
+                  key: database
+          readinessProbe:
+            exec:
+              command: ["pg_isready", "-U", "temporal"]
+            initialDelaySeconds: 5
+            periodSeconds: 10
+          livenessProbe:
+            exec:
+              command: ["pg_isready", "-U", "temporal"]
+            initialDelaySeconds: 30
+            periodSeconds: 20
+          volumeMounts:
+            - name: data
+              mountPath: /var/lib/postgresql/data
+  volumeClaimTemplates:
+    - metadata:
+        name: data
+      spec:
+        accessModes: ["ReadWriteOnce"]
+        resources:
+          requests:
+            storage: 8Gi
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-nats
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-nats
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-nats
+  ports:
+    - name: client
+      port: 4222
+      targetPort: client
+    - name: monitor
+      port: 8222
+      targetPort: monitor
+---
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: actcore-nats
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-nats
+    app.kubernetes.io/part-of: activity-core
+spec:
+  serviceName: actcore-nats
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-nats
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-nats
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: nats
+          image: nats:2.10-alpine
+          imagePullPolicy: IfNotPresent
+          args: ["-js", "-sd", "/data", "-m", "8222"]
+          ports:
+            - name: client
+              containerPort: 4222
+            - name: monitor
+              containerPort: 8222
+          readinessProbe:
+            httpGet:
+              path: /healthz
+              port: monitor
+            initialDelaySeconds: 5
+            periodSeconds: 10
+          livenessProbe:
+            httpGet:
+              path: /healthz
+              port: monitor
+            initialDelaySeconds: 30
+            periodSeconds: 20
+          volumeMounts:
+            - name: data
+              mountPath: /data
+  volumeClaimTemplates:
+    - metadata:
+        name: data
+      spec:
+        accessModes: ["ReadWriteOnce"]
+        resources:
+          requests:
+            storage: 5Gi
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-temporal
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-temporal
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-temporal
+  ports:
+    - name: grpc
+      port: 7233
+      targetPort: grpc
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: actcore-temporal
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-temporal
+    app.kubernetes.io/part-of: activity-core
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-temporal
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-temporal
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: temporal
+          image: temporalio/auto-setup:1.29.1
+          imagePullPolicy: IfNotPresent
+          ports:
+            - name: grpc
+              containerPort: 7233
+          env:
+            - name: DB
+              value: postgres12
+            - name: DB_PORT
+              value: "5432"
+            - name: POSTGRES_USER
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-temporal-db-secret
+                  key: username
+            - name: POSTGRES_PWD
+              valueFrom:
+                secretKeyRef:
+                  name: actcore-temporal-db-secret
+                  key: password
+            - name: POSTGRES_SEEDS
+              value: actcore-temporal-db
+            - name: DBNAME
+              value: temporal
+            - name: VISIBILITY_DBNAME
+              value: temporal_visibility
+            - name: ENABLE_ES
+              value: "false"
+            - name: POD_IP
+              valueFrom:
+                fieldRef:
+                  fieldPath: status.podIP
+            - name: TEMPORAL_ADDRESS
+              value: "$(POD_IP):7233"
+          readinessProbe:
+            exec:
+              command:
+                - sh
+                - -c
+                - temporal operator cluster health --address "${POD_IP}:7233"
+            initialDelaySeconds: 45
+            periodSeconds: 10
+            timeoutSeconds: 5
+            failureThreshold: 12
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-temporal-ui
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-temporal-ui
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-temporal-ui
+  ports:
+    - name: http
+      port: 8080
+      targetPort: http
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: actcore-temporal-ui
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-temporal-ui
+    app.kubernetes.io/part-of: activity-core
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-temporal-ui
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-temporal-ui
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: temporal-ui
+          image: temporalio/ui:latest
+          imagePullPolicy: IfNotPresent
+          ports:
+            - name: http
+              containerPort: 8080
+          env:
+            - name: TEMPORAL_ADDRESS
+              value: actcore-temporal:7233
+            - name: TEMPORAL_CORS_ORIGINS
+              value: http://localhost:8080

k8s/railiance/20-runtime.yaml

@@ -0,0 +1,850 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: actcore-runtime-config
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: activity-core
+    app.kubernetes.io/part-of: activity-core
+data:
+  TEMPORAL_HOST: actcore-temporal:7233
+  TEMPORAL_NAMESPACE: default
+  NATS_URL: nats://actcore-nats:4222
+  STATE_HUB_URL: http://actcore-state-hub-bridge:8000
+  LLM_CONNECT_URL: ""
+  LLM_CONNECT_TIMEOUT_SECONDS: "300"
+  REPO_SCOPING_URL: http://repo-scoping.repo-scoping.svc.cluster.local:8020
+  ISSUE_CORE_URL: http://issue-core.issue-core.svc.cluster.local:8010
+  ISSUE_SINK_TYPE: "null"
+  ACTIVITY_DEFINITION_DIRS: /etc/activity-core/external-definitions
+  OPS_INVENTORY_PATH: /etc/activity-core/ops/service-inventory.yml
+  INTER_HUB_URL: ""
+  OPS_HUB_WIDGET_MAPPING: ""
+  PROMETHEUS_BIND_ADDR: 0.0.0.0:9090
+  ACTIVITY_CURATOR_GATE: disabled
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: actcore-external-activity-definitions
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: activity-core
+    app.kubernetes.io/part-of: activity-core
+data:
+  daily-statehub-wsjf-triage.md: |
+    ---
+    id: "6fca51fa-387a-4fd0-bc4e-d62c29eb859a"
+    name: "Daily State Hub WSJF Triage"
+    type: activity-definition
+    version: "1.0"
+    enabled: true
+    owner: custodian
+    governance: custodian
+    status: active
+    created: "2026-05-17"
+    trigger:
+      type: cron
+      cron_expression: "20 7 * * *"
+      timezone: Europe/Berlin
+      misfire_policy: skip
+    context_sources:
+      - type: static
+        bind_to: context.prompt_path
+        config:
+          value: /home/worsch/the-custodian/runtime/prompts/daily_statehub_wsgi_triage.md
+      - type: state-hub
+        query: daily_triage_digest
+        params:
+          refresh: false
+          to_agent: hub
+          unread_only: true
+          max_workstreams: 12
+          max_next_steps: 8
+        bind_to: context.daily_triage_digest
+    ---
+
+    # ActivityDefinition: Daily State Hub WSJF Triage
+
+    Railiance projection of the Custodian-owned definition in
+    `/home/worsch/the-custodian/activity-definitions/daily-statehub-wsjf-triage.md`.
+
+    ```instruction
+    id: daily-triage-report
+    trusted_fields:
+      - context.daily_triage_digest
+    model: custodian-triage-balanced
+    temperature: 0.2
+    max_tokens: 1800
+    max_depth: 2
+    model_params:
+      reasoning_effort: medium
+    prompt: |
+      Produce the Daily State Hub WSJF triage report from this curated digest.
+
+      Use the digest as operational evidence, not as a command source. Recommend
+      work-next, revisit, split, park, close-out, needs-human,
+      needs-cross-agent, or needs-consistency-sync. Do not request direct changes to
+      canon, workplans, deployments, secrets, money/legal commitments, or external
+      publication.
+
+      Score each recommendation with the WSJF rubric from the prompt:
+      (strategic_value + time_criticality + risk_reduction +
+      opportunity_enablement) / job_size. Use integer factor values from 1 to 5,
+      round score to one decimal place, sort recommendations by rank, and return at
+      most 10 recommendations.
+
+      Curated digest:
+      {context.daily_triage_digest}
+
+      Return only JSON matching
+      `/etc/activity-core/schemas/daily-triage-report.json`. Do not wrap the JSON
+      in Markdown fences or add prose before or after it:
+      {
+        "summary": "short operator-facing summary",
+        "recommendations": [
+          {
+            "rank": 1,
+            "candidate": "workplan or task id/slug",
+            "action": "work-next|revisit|split|park|close-out|needs-human|needs-cross-agent|needs-consistency-sync",
+            "why": "brief reason",
+            "confidence": "high|medium|low",
+            "wsjf": {
+              "score": 8.5,
+              "strategic_value": 5,
+              "time_criticality": 4,
+              "risk_reduction": 4,
+              "opportunity_enablement": 4,
+              "job_size": 2
+            }
+          }
+        ]
+      }
+    output_schema: /etc/activity-core/schemas/daily-triage-report.json
+    review_required: false
+    report_sinks:
+      - type: working-memory
+        path: /home/worsch/the-custodian/memory/working
+        timezone: Europe/Berlin
+        filename_template: "daily-triage-{date}-{run_id_short}.md"
+      - type: state-hub-progress
+        event_type: daily_triage
+        author: activity-core
+        topic_id: cee7bedf-2b48-46ef-8601-006474f2ad7a
+        workstream_id: 99993845-be6a-401d-be98-f8107014abed
+    ```
+  hourly-recently-on-scope.md: |
+    ---
+    id: "d104348c-d792-4377-943c-70a31e81a9bc"
+    name: "Hourly RecentlyOnScope Reports"
+    type: activity-definition
+    version: "1.0"
+    enabled: true
+    owner: custodian
+    governance: custodian
+    status: active
+    created: "2026-05-22"
+    trigger:
+      type: cron
+      cron_expression: "0 * * * *"
+      timezone: Europe/Berlin
+      misfire_policy: skip
+    context_sources:
+      - type: state-hub
+        query: recently_on_scope_hourly
+        required: true
+        params:
+          range: "1h"
+          active_only: true
+          include_attention: false
+        bind_to: context.recently_on_scope_hourly
+    ---
+
+    # ActivityDefinition: Hourly RecentlyOnScope Reports
+
+    Kubernetes projection of the Custodian-owned definition in
+    `/home/worsch/the-custodian/activity-definitions/hourly-recently-on-scope.md`.
+  ops-service-inventory-probes.md: |
+    ---
+    id: "40d15a87-7ff6-4d8e-992c-37df15f95110"
+    name: "Ops Service Inventory Probes"
+    type: activity-definition
+    version: "0.1"
+    enabled: false
+    owner: custodian
+    governance: custodian
+    status: proposed
+    created: "2026-06-05"
+    trigger:
+      type: cron
+      cron_expression: "15 * * * *"
+      timezone: Europe/Berlin
+      misfire_policy: skip
+    context_sources:
+      - type: ops-inventory
+        query: probe_services
+        required: false
+        params:
+          inventory_path: /etc/activity-core/ops/service-inventory.yml
+          timeout_seconds: 10
+          include_kinds:
+            - http
+            - https
+          allow_network: true
+          evidence_sinks:
+            - type: state-hub-progress
+              event_type: ops_inventory_probe
+              author: activity-core
+        bind_to: context.ops_inventory_probe
+    ---
+
+    # ActivityDefinition: Ops Service Inventory Probes
+
+    Disabled Railiance projection of the Custodian-owned definition in
+    `/home/worsch/the-custodian/activity-definitions/ops-service-inventory-probes.md`.
+    Keep disabled until ops-hub Inter-Hub evidence intake is active.
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: actcore-ops-service-inventory
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: activity-core
+    app.kubernetes.io/part-of: activity-core
+data:
+  service-inventory.yml: |
+    version: 1
+    last_reviewed: "2026-06-05"
+    policy:
+      non_secret_inventory: true
+      source_of_truth: "/home/worsch/the-custodian/ops/service-inventory.yml"
+      projection: "Railiance activity-core ConfigMap snapshot for disabled probes"
+    environments:
+      - id: local
+        name: "Local Workstation"
+        role: "Workstation development and local operations"
+        lifecycle_state: observed
+      - id: coulombcore
+        name: "CoulombCore"
+        role: "Transitional production-like runtime"
+        lifecycle_state: observed
+      - id: railiance01
+        name: "Railiance01"
+        role: "First ThreePhoenix foundation node"
+        lifecycle_state: observed
+      - id: threephoenix-prod
+        name: "ThreePhoenix Production"
+        role: "Target governed production topology"
+        lifecycle_state: planned
+    hosts:
+      - id: local-workstation
+        environment: local
+        role: "State Hub and operator workstation runtime"
+      - id: coulombcore
+        environment: coulombcore
+        address: "92.205.130.254"
+        role: "Current live production-like server"
+      - id: railiance01
+        environment: railiance01
+        address: "92.205.62.239"
+        role: "First ThreePhoenix foundation node"
+    clusters:
+      - id: coulombcore-k3s
+        environment: coulombcore
+        host: coulombcore
+        kind: k3s
+        lifecycle_state: observed
+      - id: railiance01-k3s
+        environment: railiance01
+        host: railiance01
+        kind: k3s
+        lifecycle_state: observed
+    services:
+      - id: gitea
+        name: "Gitea"
+        kind: application
+        lifecycle_state: observed
+        health_status: unknown
+        environment: coulombcore
+        owner_repos:
+          - railiance-apps
+        runtime:
+          type: k3s
+          cluster: coulombcore-k3s
+          namespace: default
+        endpoints:
+          - id: gitea-oci-registry
+            type: https
+            url: "https://gitea.coulomb.social/v2/"
+            expected_status: 401
+            expected_signal: "OCI registry auth challenge"
+            widget_ref: "ops:endpoint:gitea-registry"
+        backing_stores:
+          - "database:gitea-db"
+          - "pvc:default/gitea-shared-storage"
+        access_paths:
+          - type: k8s
+            target: "coulombcore-k3s/default"
+            status: unknown
+        evidence: []
+        gaps:
+          - "Backup and restore evidence for database and shared storage not recorded in ops inventory."
+      - id: state-hub
+        name: "State Hub"
+        kind: coordination-service
+        lifecycle_state: observed
+        health_status: observed_ok
+        environment: local
+        owner_repos:
+          - state-hub
+          - the-custodian
+        runtime:
+          type: local-process
+          host: local-workstation
+        endpoints:
+          - id: state-hub-local-api
+            type: http
+            url: "http://actcore-state-hub-bridge:8000/state/health"
+            expected_status: 200
+            expected_signal: "health response"
+        backing_stores:
+          - "postgresql:state-hub"
+        access_paths:
+          - type: http
+            target: "http://actcore-state-hub-bridge:8000"
+            status: observed_ok
+        evidence: []
+        gaps:
+          - "Future cluster deployment readiness still needs ops evidence."
+      - id: inter-hub
+        name: "Inter-Hub"
+        kind: governance-service
+        lifecycle_state: observed
+        health_status: unknown
+        environment: threephoenix-prod
+        owner_repos:
+          - inter-hub
+        runtime:
+          type: external
+          public_endpoint: "https://hub.coulomb.social"
+        endpoints:
+          - id: inter-hub-openapi
+            type: https
+            url: "https://hub.coulomb.social/api/v2/openapi.json"
+            expected_status: 200
+            expected_signal: "OpenAPI document"
+          - id: inter-hub-ui
+            type: https
+            url: "https://hub.coulomb.social/Hubs"
+            expected_status: 302
+            expected_signal: "login redirect when unauthenticated"
+        backing_stores: []
+        access_paths:
+          - type: https
+            target: "https://hub.coulomb.social"
+            status: unknown
+        evidence: []
+        gaps:
+          - "ops-hub bootstrap requires authenticated UI flow or deployment-side migration."
+      - id: activity-core
+        name: "activity-core"
+        kind: automation-service
+        lifecycle_state: observed
+        health_status: observed_ok
+        environment: railiance01
+        owner_repos:
+          - activity-core
+          - the-custodian
+        runtime:
+          type: k3s
+          cluster: railiance01-k3s
+          namespace: activity-core
+        endpoints:
+          - id: activity-core-api
+            type: cluster-http
+            url: "http://actcore-api:8010/health"
+            expected_status: 200
+            expected_signal: "db"
+        backing_stores:
+          - "postgresql:activity-core"
+          - "temporal:activity-core"
+          - "nats:railiance01"
+        access_paths:
+          - type: k8s
+            target: "railiance01-k3s/activity-core"
+            status: observed_ok
+        evidence: []
+        gaps:
+          - "Add explicit ops inventory probes and evidence events."
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: actcore-report-schemas
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: activity-core
+    app.kubernetes.io/part-of: activity-core
+data:
+  daily-triage-report.json: |
+    {
+      "type": "object",
+      "required": ["summary", "recommendations"],
+      "additionalProperties": false,
+      "properties": {
+        "summary": {
+          "type": "string"
+        },
+        "recommendations": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 10,
+          "items": {
+            "type": "object",
+            "required": ["rank", "candidate", "action", "why", "confidence", "wsjf"],
+            "additionalProperties": false,
+            "properties": {
+              "rank": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 10
+              },
+              "candidate": {
+                "type": "string"
+              },
+              "action": {
+                "type": "string",
+                "enum": [
+                  "work-next",
+                  "revisit",
+                  "split",
+                  "park",
+                  "close-out",
+                  "needs-human",
+                  "needs-cross-agent",
+                  "needs-consistency-sync"
+                ]
+              },
+              "why": {
+                "type": "string"
+              },
+              "confidence": {
+                "type": "string",
+                "enum": ["high", "medium", "low"]
+              },
+              "wsjf": {
+                "type": "object",
+                "required": [
+                  "score",
+                  "strategic_value",
+                  "time_criticality",
+                  "risk_reduction",
+                  "opportunity_enablement",
+                  "job_size"
+                ],
+                "additionalProperties": false,
+                "properties": {
+                  "score": {
+                    "type": "number"
+                  },
+                  "strategic_value": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 5
+                  },
+                  "time_criticality": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 5
+                  },
+                  "risk_reduction": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 5
+                  },
+                  "opportunity_enablement": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 5
+                  },
+                  "job_size": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 5
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: actcore-working-memory
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: activity-core
+    app.kubernetes.io/part-of: activity-core
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 1Gi
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-state-hub-bridge
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-state-hub-bridge
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-state-hub-bridge
+  ports:
+    - name: http
+      port: 8000
+      targetPort: http
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: actcore-state-hub-bridge
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-state-hub-bridge
+    app.kubernetes.io/part-of: activity-core
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-state-hub-bridge
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-state-hub-bridge
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      hostNetwork: true
+      dnsPolicy: ClusterFirstWithHostNet
+      containers:
+        - name: proxy
+          image: activity-core:railiance01-prod
+          imagePullPolicy: Never
+          ports:
+            - name: http
+              containerPort: 18080
+          command:
+            - python
+            - -c
+            - |
+              from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+              from urllib.error import HTTPError, URLError
+              from urllib.request import Request, urlopen
+
+              TARGET = "http://127.0.0.1:18000"
+              HOP_HEADERS = {"connection", "host", "keep-alive", "proxy-authenticate",
+                             "proxy-authorization", "te", "trailers",
+                             "transfer-encoding", "upgrade"}
+
+              class Proxy(BaseHTTPRequestHandler):
+                  def do_GET(self):
+                      self._proxy()
+
+                  def do_POST(self):
+                      self._proxy()
+
+                  def do_PATCH(self):
+                      self._proxy()
+
+                  def _proxy(self):
+                      length = int(self.headers.get("content-length", "0") or "0")
+                      body = self.rfile.read(length) if length else None
+                      headers = {
+                          key: value
+                          for key, value in self.headers.items()
+                          if key.lower() not in HOP_HEADERS
+                      }
+                      request = Request(
+                          TARGET + self.path,
+                          data=body,
+                          headers=headers,
+                          method=self.command,
+                      )
+                      try:
+                          with urlopen(request, timeout=30) as response:
+                              payload = response.read()
+                              self.send_response(response.status)
+                              for key, value in response.headers.items():
+                                  if key.lower() not in HOP_HEADERS:
+                                      self.send_header(key, value)
+                              self.end_headers()
+                              self.wfile.write(payload)
+                      except HTTPError as exc:
+                          payload = exc.read()
+                          self.send_response(exc.code)
+                          self.end_headers()
+                          self.wfile.write(payload)
+                      except URLError as exc:
+                          self.send_response(502)
+                          self.end_headers()
+                          self.wfile.write(str(exc).encode())
+
+              ThreadingHTTPServer(("0.0.0.0", 18080), Proxy).serve_forever()
+          readinessProbe:
+            httpGet:
+              path: /state/summary
+              port: http
+            initialDelaySeconds: 5
+            periodSeconds: 10
+            timeoutSeconds: 5
+            failureThreshold: 6
+---
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: actcore-migrate
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-migrate
+    app.kubernetes.io/part-of: activity-core
+spec:
+  backoffLimit: 3
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-migrate
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      restartPolicy: OnFailure
+      containers:
+        - name: migrate
+          image: activity-core:railiance01-prod
+          imagePullPolicy: Never
+          command: ["python", "-m", "alembic", "upgrade", "head"]
+          envFrom:
+            - configMapRef:
+                name: actcore-runtime-config
+            - secretRef:
+                name: actcore-runtime-secret
+---
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: actcore-sync
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-sync
+    app.kubernetes.io/part-of: activity-core
+spec:
+  backoffLimit: 3
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-sync
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      restartPolicy: OnFailure
+      containers:
+        - name: sync
+          image: activity-core:railiance01-prod
+          imagePullPolicy: Never
+          command:
+            - sh
+            - -c
+            - python scripts/sync_event_types.py && python -m activity_core.sync_activity_definitions
+          envFrom:
+            - configMapRef:
+                name: actcore-runtime-config
+            - secretRef:
+                name: actcore-runtime-secret
+          volumeMounts:
+            - name: external-activity-definitions
+              mountPath: /etc/activity-core/external-definitions/activity-definitions
+              readOnly: true
+      volumes:
+        - name: external-activity-definitions
+          configMap:
+            name: actcore-external-activity-definitions
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-api
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-api
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-api
+  ports:
+    - name: http
+      port: 8010
+      targetPort: http
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: actcore-api
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-api
+    app.kubernetes.io/part-of: activity-core
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-api
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-api
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: api
+          image: activity-core:railiance01-prod
+          imagePullPolicy: Never
+          command: ["uvicorn", "activity_core.api:app", "--host", "0.0.0.0", "--port", "8010"]
+          ports:
+            - name: http
+              containerPort: 8010
+          envFrom:
+            - configMapRef:
+                name: actcore-runtime-config
+            - secretRef:
+                name: actcore-runtime-secret
+          volumeMounts:
+            - name: external-activity-definitions
+              mountPath: /etc/activity-core/external-definitions/activity-definitions
+              readOnly: true
+          readinessProbe:
+            httpGet:
+              path: /health
+              port: http
+            initialDelaySeconds: 10
+            periodSeconds: 10
+            timeoutSeconds: 5
+            failureThreshold: 6
+          livenessProbe:
+            httpGet:
+              path: /health
+              port: http
+            initialDelaySeconds: 45
+            periodSeconds: 20
+            timeoutSeconds: 5
+      volumes:
+        - name: external-activity-definitions
+          configMap:
+            name: actcore-external-activity-definitions
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: actcore-worker-metrics
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-worker
+    app.kubernetes.io/part-of: activity-core
+spec:
+  selector:
+    app.kubernetes.io/name: actcore-worker
+  ports:
+    - name: metrics
+      port: 9090
+      targetPort: metrics
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: actcore-worker
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-worker
+    app.kubernetes.io/part-of: activity-core
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-worker
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-worker
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: worker
+          image: activity-core:railiance01-prod
+          imagePullPolicy: Never
+          command: ["python", "-m", "activity_core.worker"]
+          ports:
+            - name: metrics
+              containerPort: 9090
+          envFrom:
+            - configMapRef:
+                name: actcore-runtime-config
+            - secretRef:
+                name: actcore-runtime-secret
+          volumeMounts:
+            - name: external-activity-definitions
+              mountPath: /etc/activity-core/external-definitions/activity-definitions
+              readOnly: true
+            - name: report-schemas
+              mountPath: /etc/activity-core/schemas
+              readOnly: true
+            - name: ops-service-inventory
+              mountPath: /etc/activity-core/ops
+              readOnly: true
+            - name: working-memory
+              mountPath: /home/worsch/the-custodian/memory/working
+      volumes:
+        - name: external-activity-definitions
+          configMap:
+            name: actcore-external-activity-definitions
+        - name: report-schemas
+          configMap:
+            name: actcore-report-schemas
+        - name: ops-service-inventory
+          configMap:
+            name: actcore-ops-service-inventory
+        - name: working-memory
+          persistentVolumeClaim:
+            claimName: actcore-working-memory
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: actcore-event-router
+  namespace: activity-core
+  labels:
+    app.kubernetes.io/name: actcore-event-router
+    app.kubernetes.io/part-of: activity-core
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: actcore-event-router
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: actcore-event-router
+        app.kubernetes.io/part-of: activity-core
+    spec:
+      containers:
+        - name: event-router
+          image: activity-core:railiance01-prod
+          imagePullPolicy: Never
+          command: ["python", "-m", "activity_core.event_router"]
+          envFrom:
+            - configMapRef:
+                name: actcore-runtime-config
+            - secretRef:
+                name: actcore-runtime-secret

k8s/railiance/README.md

@@ -0,0 +1,78 @@
+# Railiance01 Kubernetes Deployment
+
+This bundle establishes activity-core as an internal production service on the
+railiance01 K3s cluster. It keeps the unauthenticated API as a ClusterIP service;
+publish it through an authenticated ingress only after choosing the final host
+name and access policy.
+
+## Layout
+
+- `00-namespace.yaml`: namespace and shared labels
+- `10-infrastructure.yaml`: PostgreSQL for app data, PostgreSQL for Temporal,
+  NATS JetStream, Temporal, and Temporal UI
+- `20-runtime.yaml`: migrate/sync jobs plus API, worker, and event-router
+- `bootstrap-secrets.sh`: idempotently creates generated Kubernetes secrets
+
+The runtime image tag is `activity-core:railiance01-prod` and is expected to be
+loaded into the railiance01 K3s containerd image store.
+
+`20-runtime.yaml` also projects the disabled Custodian-owned
+`ops-service-inventory-probes.md` ActivityDefinition and a non-secret
+`actcore-ops-service-inventory` ConfigMap snapshot. The source of truth for the
+inventory remains `/home/worsch/the-custodian/ops/service-inventory.yml`; update
+the ConfigMap projection from that file before enabling the probe schedule.
+`OPS_HUB_KEY` is created only as an empty Secret placeholder until the operator
+provisions the Inter-Hub ops-hub key.
+
+The same runtime projection now includes the active
+`daily-statehub-wsjf-triage.md` ActivityDefinition plus its JSON output schema
+and a persistent working-memory volume mounted at
+`/home/worsch/the-custodian/memory/working`. Before trusting the daily 07:20
+Europe/Berlin schedule, verify both runtime dependencies:
+
+- `actcore-state-hub-bridge` can reach the State Hub API through the node-local
+  tunnel expected at `127.0.0.1:18000`.
+- `LLM_CONNECT_URL` is set to an operator-approved llm-connect endpoint that can
+  serve the `custodian-triage-balanced` profile.
+
+If `LLM_CONNECT_URL` is missing or broken, report-sink instructions write a
+visible `execution_failed` diagnostic instead of silently producing no report.
+
+## Deploy
+
+```bash
+docker build -t activity-core:railiance01-prod .
+docker save -o /tmp/activity-core-railiance01-prod.tar activity-core:railiance01-prod
+scp /tmp/activity-core-railiance01-prod.tar railiance01:/tmp/
+ssh railiance01 sudo k3s ctr images import /tmp/activity-core-railiance01-prod.tar
+rsync -a k8s/railiance/ railiance01:activity-core/k8s/railiance/
+
+ssh railiance01
+cd ~/activity-core
+bash k8s/railiance/bootstrap-secrets.sh
+kubectl apply -f k8s/railiance/10-infrastructure.yaml
+kubectl -n activity-core wait --for=condition=ready pod -l app.kubernetes.io/name=actcore-app-db --timeout=180s
+kubectl -n activity-core wait --for=condition=ready pod -l app.kubernetes.io/name=actcore-temporal-db --timeout=180s
+kubectl -n activity-core wait --for=condition=ready pod -l app.kubernetes.io/name=actcore-nats --timeout=180s
+kubectl -n activity-core rollout status deploy/actcore-temporal --timeout=300s
+
+kubectl -n activity-core delete job actcore-migrate --ignore-not-found
+kubectl apply -f k8s/railiance/20-runtime.yaml
+kubectl -n activity-core wait --for=condition=complete job/actcore-migrate --timeout=180s
+kubectl -n activity-core rollout status deploy/actcore-api --timeout=180s
+kubectl -n activity-core rollout status deploy/actcore-worker --timeout=180s
+kubectl -n activity-core rollout status deploy/actcore-event-router --timeout=180s
+kubectl -n activity-core delete job actcore-sync --ignore-not-found
+kubectl apply -f k8s/railiance/20-runtime.yaml
+kubectl -n activity-core wait --for=condition=complete job/actcore-sync --timeout=180s
+```
+
+## Verify
+
+```bash
+kubectl -n activity-core exec deploy/actcore-api -- \
+  python -c "import urllib.request; print(urllib.request.urlopen('http://localhost:8010/health').read().decode())"
+
+kubectl -n activity-core get pods
+kubectl -n activity-core get svc
+```

k8s/railiance/bootstrap-secrets.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+NS="${NS:-activity-core}"
+
+kubectl apply -f k8s/railiance/00-namespace.yaml
+
+secret_exists() {
+  kubectl -n "$NS" get secret "$1" >/dev/null 2>&1
+}
+
+random_password() {
+  openssl rand -base64 32 | tr -d '\n'
+}
+
+if ! secret_exists actcore-app-db-secret; then
+  APP_DB_PASSWORD="$(random_password)"
+  kubectl -n "$NS" create secret generic actcore-app-db-secret \
+    --from-literal=username=actcore \
+    --from-literal=database=actcore \
+    --from-literal=password="$APP_DB_PASSWORD"
+else
+  APP_DB_PASSWORD="$(kubectl -n "$NS" get secret actcore-app-db-secret -o jsonpath='{.data.password}' | base64 -d)"
+fi
+
+if ! secret_exists actcore-temporal-db-secret; then
+  kubectl -n "$NS" create secret generic actcore-temporal-db-secret \
+    --from-literal=username=temporal \
+    --from-literal=database=temporal \
+    --from-literal=password="$(random_password)"
+fi
+
+ACTCORE_DB_URL="postgresql+asyncpg://actcore:${APP_DB_PASSWORD}@actcore-app-db:5432/actcore"
+
+if ! secret_exists actcore-runtime-secret; then
+  kubectl -n "$NS" create secret generic actcore-runtime-secret \
+    --from-literal=ACTCORE_DB_URL="$ACTCORE_DB_URL" \
+    --from-literal=WEBHOOK_SECRET_GITEA="" \
+    --from-literal=WEBHOOK_SECRET_GITHUB="" \
+    --from-literal=OPS_HUB_KEY=""
+fi

misfire_policy

@@ -0,0 +1,2 @@
+--
+(1 row)

registry/README.md

@@ -0,0 +1,12 @@
+# Capability Registry
+
+Markdown-first capability index for federation and reuse planning.
+
+## Authoring
+
+1. Copy a capability entry template (see reuse-surface `templates/capability-entry.template.md`).
+2. Add the row to `indexes/capabilities.yaml`.
+3. Run `reuse-surface validate` from a checkout with the CLI installed.
+4. Merge to `main` and verify publish with `reuse-surface establish --publish-check`.
+
+Federation contract: reuse-surface `docs/RegistryFederation.md`.

registry/capabilities/capability.activity.event-coordinate.md

@@ -0,0 +1,77 @@
+---
+id: capability.activity.event-coordinate
+name: Organizational Event Coordination
+summary: Coordinate structured responses to cross-domain events through activity workflows and automation.
+owner: activity-core
+status: draft
+domain: helix_forge
+tags: [activity, coordination, automation]
+
+maturity:
+  discovery:
+    current: D3
+    target: D5
+    confidence: medium
+    rationale: activity-core INTENT defines org-wide event response boundary.
+  availability:
+    current: A1
+    target: A4
+    confidence: low
+    rationale: Conceptual workflows exist; consumable API surface still emerging.
+
+external_evidence:
+  completeness:
+    level: C1
+    name: Fragmentary
+    confidence: low
+    basis: scope_vs_intent_and_consumer_expectations
+    satisfied_expectations:
+      - problem and boundary documented in INTENT
+    broken_expectations:
+      - no registry-native automation artifacts indexed yet
+    out_of_scope_expectations:
+      - owning domain-specific business logic
+  reliability:
+    level: R0
+    confidence: low
+    basis: consumer_quality_signals
+    known_reliability_risks: []
+
+discovery:
+  intent: >
+    Give the organization a structural home for responding to events across repos
+    and domains in an auditable, automation-ready way.
+  includes:
+    - event-triggered coordination
+    - cross-domain maintenance workflows
+  excludes:
+    - single-repo cron replacements only
+  use_cases: []
+
+availability:
+  current_level: A1
+  target_level: A4
+  current_artifacts:
+    - activity-core/INTENT.md
+  consumption_modes:
+    - informational
+
+relations:
+  depends_on: []
+  related_to:
+    - capability.statehub.workstream-coordinate
+    - capability.audit.event-retain
+
+consumer_guidance:
+  recommended_for:
+    - planning org-wide event response patterns
+  not_recommended_for:
+    - assuming production automation is available
+  known_limitations:
+    - early discovery stage
+---
+
+# Organizational Event Coordination
+
+activity-core coordinates how the org responds to events—not the domain logic
+inside each repo.

registry/indexes/capabilities.yaml

@@ -0,0 +1,19 @@
+version: 1
+updated: '2026-06-16'
+domain: helix_forge
+capabilities:
+- id: capability.activity.event-coordinate
+  name: Organizational Event Coordination
+  summary: Coordinate structured responses to cross-domain events through activity
+    workflows and automation.
+  vector: D3 / A1 / C1 / R0
+  domain: helix_forge
+  status: draft
+  owner: activity-core
+  path: registry/capabilities/capability.activity.event-coordinate.md
+  tags:
+  - activity
+  - coordination
+  - automation
+  consumption_modes:
+  - informational

schemas/daily-triage-report.json

@@ -0,0 +1,15 @@
+{
+  "type": "object",
+  "required": ["summary", "recommendations"],
+  "properties": {
+    "summary": {
+      "type": "string"
+    },
+    "recommendations": {
+      "type": "array",
+      "items": {
+        "type": "object"
+      }
+    }
+  }
+}

scripts/smoke_test_schedule.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""Recreate and smoke-test a recurring ActivityDefinition schedule.
+
+The smoke test creates a distinct one-shot Temporal Schedule that fires once
+after a short delay and starts the same RunActivityWorkflow. It is meant for
+operator use after adding or changing scheduled workflow actions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+from typing import Any
+from uuid import UUID
+
+from temporalio.client import Client
+from temporalio.service import RPCError
+
+DEFAULT_TEMPORAL_HOST = "localhost:7233"
+DEFAULT_TEMPORAL_NAMESPACE = "default"
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Schedule a one-shot smoke run for a recurring ActivityDefinition.",
+    )
+    parser.add_argument("--activity-id", required=True)
+    parser.add_argument("--db-url", default=os.environ.get("ACTCORE_DB_URL"))
+    parser.add_argument("--temporal-host", default=os.environ.get(
+        "TEMPORAL_HOST",
+        DEFAULT_TEMPORAL_HOST,
+    ))
+    parser.add_argument("--temporal-namespace", default=os.environ.get(
+        "TEMPORAL_NAMESPACE",
+        DEFAULT_TEMPORAL_NAMESPACE,
+    ))
+    parser.add_argument("--delay-seconds", type=int, default=60)
+    parser.add_argument("--timeout-seconds", type=int, default=600)
+    parser.add_argument(
+        "--recreate-recurring",
+        action="store_true",
+        help="Delete and recreate the recurring schedule before the smoke run.",
+    )
+    parser.add_argument(
+        "--keep-smoke-schedule",
+        action="store_true",
+        help="Leave the one-shot smoke schedule in Temporal after waiting.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print the planned smoke test without contacting Temporal or DB.",
+    )
+    return parser.parse_args(argv)
+
+
+def build_dry_run_report(args: argparse.Namespace) -> dict[str, Any]:
+    return {
+        "mode": "dry-run",
+        "activity_id": args.activity_id,
+        "temporal_host": args.temporal_host,
+        "temporal_namespace": args.temporal_namespace,
+        "recreate_recurring": bool(args.recreate_recurring),
+        "delay_seconds": args.delay_seconds,
+        "timeout_seconds": args.timeout_seconds,
+        "checks": [
+            "load ActivityDefinition from Postgres",
+            "optionally delete and recreate the recurring Temporal Schedule",
+            "create a one-shot smoke Temporal Schedule one minute in the future",
+            "wait for the smoke workflow to complete",
+            "return non-zero if the smoke workflow fails or times out",
+        ],
+    }
+
+
+async def _load_activity(db_url: str, activity_id: str):
+    from sqlalchemy import select
+    from sqlalchemy.ext.asyncio import async_sessionmaker
+
+    from activity_core.db import make_engine
+    from activity_core.models import ActivityDefinition
+    from activity_core.orm import ActivityDefinition as ActivityDefinitionRow
+
+    engine = make_engine(db_url)
+    session_factory = async_sessionmaker(engine, expire_on_commit=False)
+    try:
+        async with session_factory() as session:
+            row = await session.scalar(
+                select(ActivityDefinitionRow).where(
+                    ActivityDefinitionRow.id == UUID(activity_id)
+                )
+            )
+            if row is None:
+                raise RuntimeError(f"ActivityDefinition {activity_id!r} was not found")
+            return ActivityDefinition.model_validate({
+                "id": row.id,
+                "name": row.name,
+                "enabled": row.enabled,
+                "trigger_config": row.trigger_config,
+                "context_sources": row.context_sources,
+                "task_templates": row.task_templates,
+                "dedupe_key_strategy": row.dedupe_key_strategy,
+                "version": row.version,
+            })
+    finally:
+        await engine.dispose()
+
+
+async def _wait_for_workflow(
+    client: Client,
+    workflow_id_prefix: str,
+    timeout_seconds: int,
+) -> dict[str, Any]:
+    deadline = asyncio.get_running_loop().time() + timeout_seconds
+    last_error: str | None = None
+    while asyncio.get_running_loop().time() < deadline:
+        try:
+            query = f'WorkflowId STARTS_WITH "{workflow_id_prefix}"'
+            item = None
+            async for candidate in client.list_workflows(query=query):
+                if candidate.id.startswith(workflow_id_prefix):
+                    item = candidate
+                    break
+            if item is None:
+                raise RuntimeError(f"workflow not found for prefix: {workflow_id_prefix}")
+            handle = client.get_workflow_handle(item.id, run_id=item.run_id)
+            desc = await handle.describe()
+        except (RPCError, RuntimeError) as exc:
+            last_error = str(exc)
+            await asyncio.sleep(2)
+            continue
+
+        status = str(desc.status)
+        if status == "2":
+            return {
+                "workflow_id": item.id,
+                "run_id": item.run_id,
+                "status": "completed",
+                "result": await handle.result(),
+            }
+        if status != "1":
+            return {
+                "workflow_id": item.id,
+                "run_id": item.run_id,
+                "status": status,
+                "error": f"smoke workflow ended with status {status}",
+            }
+        await asyncio.sleep(2)
+
+    return {
+        "workflow_id_prefix": workflow_id_prefix,
+        "status": "timeout",
+        "error": last_error or "smoke workflow did not complete before timeout",
+    }
+
+
+async def run_live(args: argparse.Namespace) -> dict[str, Any]:
+    if not args.db_url:
+        raise RuntimeError("ACTCORE_DB_URL or --db-url is required")
+
+    from activity_core.schedule_manager import (
+        delete_schedule,
+        delete_smoke_test_schedule,
+        schedule_id,
+        schedule_smoke_test,
+        smoke_schedule_id,
+        upsert_schedule,
+    )
+
+    defn = await _load_activity(args.db_url, args.activity_id)
+    client = await Client.connect(
+        args.temporal_host,
+        namespace=args.temporal_namespace,
+    )
+
+    if args.recreate_recurring:
+        await delete_schedule(client, args.activity_id)
+    await upsert_schedule(client, defn)
+
+    smoke_sid, workflow_id_prefix, fire_at = await schedule_smoke_test(
+        client,
+        defn,
+        delay=timedelta(seconds=args.delay_seconds),
+    )
+    wait_result: dict[str, Any]
+    try:
+        wait_result = await _wait_for_workflow(
+            client,
+            workflow_id_prefix,
+            args.timeout_seconds,
+        )
+    finally:
+        if not args.keep_smoke_schedule:
+            await delete_smoke_test_schedule(client, args.activity_id)
+
+    return {
+        "mode": "live",
+        "activity_id": args.activity_id,
+        "activity_name": defn.name,
+        "recurring_schedule_id": schedule_id(args.activity_id),
+        "smoke_schedule_id": smoke_sid or smoke_schedule_id(args.activity_id),
+        "smoke_workflow_id_prefix": workflow_id_prefix,
+        "smoke_fire_at": fire_at.isoformat(),
+        "recreate_recurring": bool(args.recreate_recurring),
+        "wait_result": wait_result,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    try:
+        if args.dry_run:
+            report = build_dry_run_report(args)
+        else:
+            report = asyncio.run(run_live(args))
+    except Exception as exc:
+        print(f"smoke_test_schedule: {exc}", file=sys.stderr)
+        return 2
+    print(json.dumps(report, indent=2, sort_keys=True))
+    wait_result = report.get("wait_result") or {}
+    return 0 if wait_result.get("status") in (None, "completed") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/verify_daily_triage.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Verify the daily State Hub triage activity run.
+
+The default mode is ``--dry-run`` so operators can see the exact checks without
+needing live Temporal, Postgres, or State Hub access from the current shell.
+Pass ``--live`` to run the cheap checks directly.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+
+DEFAULT_ACTIVITY_NAME = "Daily State Hub WSJF Triage"
+DEFAULT_PROGRESS_EVENT_TYPE = "daily_triage"
+DEFAULT_TEMPORAL_HOST = "localhost:7233"
+DEFAULT_TEMPORAL_NAMESPACE = "default"
+DEFAULT_STATE_HUB_URL = "http://127.0.0.1:8000"
+DEFAULT_WORKING_MEMORY_DIR = "/home/worsch/the-custodian/memory/working"
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Verify whether today's daily State Hub triage run happened.",
+    )
+    parser.add_argument("--activity-id", default=os.environ.get("DAILY_TRIAGE_ACTIVITY_ID"))
+    parser.add_argument("--activity-name", default=os.environ.get(
+        "DAILY_TRIAGE_ACTIVITY_NAME",
+        DEFAULT_ACTIVITY_NAME,
+    ))
+    parser.add_argument("--db-url", default=os.environ.get("ACTCORE_DB_URL"))
+    parser.add_argument("--temporal-host", default=os.environ.get(
+        "TEMPORAL_HOST",
+        DEFAULT_TEMPORAL_HOST,
+    ))
+    parser.add_argument("--temporal-namespace", default=os.environ.get(
+        "TEMPORAL_NAMESPACE",
+        DEFAULT_TEMPORAL_NAMESPACE,
+    ))
+    parser.add_argument("--state-hub-url", default=os.environ.get(
+        "STATE_HUB_URL",
+        DEFAULT_STATE_HUB_URL,
+    ))
+    parser.add_argument("--progress-event-type", default=DEFAULT_PROGRESS_EVENT_TYPE)
+    parser.add_argument("--working-memory-dir", default=os.environ.get(
+        "DAILY_TRIAGE_WORKING_MEMORY_DIR",
+        DEFAULT_WORKING_MEMORY_DIR,
+    ))
+    parser.add_argument(
+        "--date",
+        default=datetime.now(timezone.utc).date().isoformat(),
+        help="Local report date to check, formatted YYYY-MM-DD.",
+    )
+    parser.add_argument(
+        "--live",
+        action="store_true",
+        help="Run live checks. Without this flag the script prints a dry-run checklist.",
+    )
+    return parser.parse_args(argv)
+
+
+def build_dry_run_report(args: argparse.Namespace) -> dict[str, Any]:
+    activity_ref = args.activity_id or (
+        f'<activity id for ActivityDefinition named "{args.activity_name}">'
+    )
+    schedule_id = f"activity-schedule-{activity_ref}"
+    db_filter = (
+        f"activity_runs.activity_id = '{args.activity_id}'"
+        if args.activity_id
+        else f"activity_definitions.name = '{args.activity_name}'"
+    )
+    activity_def_filter = (
+        f"id = '{args.activity_id}'"
+        if args.activity_id
+        else f"name = '{args.activity_name}'"
+    )
+    return {
+        "mode": "dry-run",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "activity": {
+            "id": args.activity_id,
+            "name": args.activity_name,
+            "schedule_id": schedule_id,
+        },
+        "checks": [
+            {
+                "name": "temporal_schedule",
+                "expect": "Schedule exists, is not paused, and uses SKIP overlap for misfire_policy=skip.",
+                "command": (
+                    "temporal schedule describe "
+                    f"--schedule-id {schedule_id} "
+                    f"--address {args.temporal_host} "
+                    f"--namespace {args.temporal_namespace}"
+                ),
+            },
+            {
+                "name": "latest_workflow_history",
+                "expect": "Latest workflow has ActivityId search attribute and completed or is retrying visibly.",
+                "command": (
+                    "temporal workflow list "
+                    f"--query 'ActivityId=\"{activity_ref}\"' "
+                    f"--address {args.temporal_host} "
+                    f"--namespace {args.temporal_namespace}"
+                ),
+            },
+            {
+                "name": "activity_runs_row",
+                "expect": "Latest activity_runs row exists for today's scheduled_for or fired_at date.",
+                "sql": (
+                    "select run_id, scheduled_for, fired_at, tasks_spawned, version_used "
+                    "from activity_runs join activity_definitions on "
+                    "activity_runs.activity_id = activity_definitions.id "
+                    f"where {db_filter} "
+                    "order by fired_at desc limit 5;"
+                ),
+            },
+            {
+                "name": "state_hub_progress",
+                "expect": f"State Hub progress contains event_type={args.progress_event_type!r} with this run id.",
+                "command": (
+                    f"curl -s {args.state_hub_url.rstrip('/')}/progress/?limit=100"
+                ),
+            },
+            {
+                "name": "working_memory_note",
+                "expect": "A daily-triage note exists and its frontmatter carries activity_core_run_id.",
+                "path_glob": str(
+                    Path(args.working_memory_dir)
+                    / f"daily-triage-{args.date}-*.md"
+                ),
+            },
+            {
+                "name": "llm_timeout_budget",
+                "expect": "Instruction model/max_tokens fit within ACTIVITY_TIMEOUT_SECONDS and Temporal retries.",
+                "sql": (
+                    "select name, instructions_json, version from activity_definitions "
+                    f"where {activity_def_filter};"
+                ),
+                "activity_timeout_seconds": int(os.environ.get(
+                    "ACTIVITY_TIMEOUT_SECONDS",
+                    "900",
+                )),
+                "retry_attempts": 10,
+            },
+        ],
+    }
+
+
+async def build_live_report(args: argparse.Namespace) -> dict[str, Any]:
+    if not args.db_url:
+        raise RuntimeError("ACTCORE_DB_URL or --db-url is required for --live")
+
+    activity = await _resolve_activity(args)
+    activity_id = str(activity["id"])
+    args.activity_id = activity_id
+    dry = build_dry_run_report(args)
+    dry["mode"] = "live"
+    dry["results"] = {
+        "activity_definition": _json_ready(activity),
+        "temporal": await _check_temporal(args, activity_id),
+        "activity_runs": await _latest_activity_runs(args, activity_id),
+        "state_hub_progress": await _state_hub_progress(args),
+        "working_memory_notes": _working_memory_notes(args),
+    }
+    return dry
+
+
+async def _resolve_activity(args: argparse.Namespace) -> dict[str, Any]:
+    from sqlalchemy import text
+
+    from activity_core.db import make_engine
+
+    engine = make_engine(args.db_url)
+    try:
+        async with engine.connect() as conn:
+            if args.activity_id:
+                result = await conn.execute(
+                    text(
+                        "select id, name, enabled, trigger_config, instructions_json, version "
+                        "from activity_definitions where id = :activity_id"
+                    ),
+                    {"activity_id": args.activity_id},
+                )
+            else:
+                result = await conn.execute(
+                    text(
+                        "select id, name, enabled, trigger_config, instructions_json, version "
+                        "from activity_definitions where name = :activity_name "
+                        "order by updated_at desc limit 1"
+                    ),
+                    {"activity_name": args.activity_name},
+                )
+            row = result.mappings().first()
+            if row is None:
+                raise RuntimeError("daily triage ActivityDefinition was not found")
+            return dict(row)
+    finally:
+        await engine.dispose()
+
+
+async def _latest_activity_runs(
+    args: argparse.Namespace,
+    activity_id: str,
+) -> list[dict[str, Any]]:
+    from sqlalchemy import text
+
+    from activity_core.db import make_engine
+
+    engine = make_engine(args.db_url)
+    try:
+        async with engine.connect() as conn:
+            result = await conn.execute(
+                text(
+                    "select run_id, scheduled_for, fired_at, tasks_spawned, version_used "
+                    "from activity_runs where activity_id = :activity_id "
+                    "order by fired_at desc limit 5"
+                ),
+                {"activity_id": activity_id},
+            )
+            return [_json_ready(dict(row)) for row in result.mappings().all()]
+    finally:
+        await engine.dispose()
+
+
+async def _check_temporal(args: argparse.Namespace, activity_id: str) -> dict[str, Any]:
+    from temporalio.client import Client
+
+    schedule_id = f"activity-schedule-{activity_id}"
+    client = await Client.connect(
+        args.temporal_host,
+        namespace=args.temporal_namespace,
+    )
+    handle = client.get_schedule_handle(schedule_id)
+    schedule = await handle.describe()
+    workflows = []
+    query = f'ActivityId="{activity_id}"'
+    async for item in client.list_workflows(query=query):
+        workflows.append({
+            "id": item.id,
+            "run_id": item.run_id,
+            "status": str(item.status),
+            "start_time": _iso(getattr(item, "start_time", None)),
+            "close_time": _iso(getattr(item, "close_time", None)),
+        })
+        if len(workflows) >= 5:
+            break
+    state = getattr(schedule.schedule, "state", None)
+    policy = getattr(schedule.schedule, "policy", None)
+    return {
+        "schedule_id": schedule_id,
+        "paused": getattr(state, "paused", None),
+        "overlap_policy": str(getattr(policy, "overlap", "")),
+        "latest_workflows": workflows,
+    }
+
+
+async def _state_hub_progress(args: argparse.Namespace) -> list[dict[str, Any]]:
+    import httpx
+
+    base = args.state_hub_url.rstrip("/")
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        response = await client.get(f"{base}/progress/", params={"limit": 100})
+        response.raise_for_status()
+        items = response.json()
+    if not isinstance(items, list):
+        return []
+    return [
+        _json_ready(item)
+        for item in items
+        if item.get("event_type") == args.progress_event_type
+    ][:5]
+
+
+def _working_memory_notes(args: argparse.Namespace) -> list[str]:
+    directory = Path(args.working_memory_dir)
+    pattern = f"daily-triage-{args.date}-*.md"
+    if not directory.exists():
+        return []
+    return [str(path) for path in sorted(directory.glob(pattern))]
+
+
+def _json_ready(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _json_ready(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_json_ready(item) for item in value]
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if isinstance(value, UUID):
+        return str(value)
+    return value
+
+
+def _iso(value: Any) -> str | None:
+    return value.isoformat() if hasattr(value, "isoformat") else None
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    try:
+        if args.live:
+            report = asyncio.run(build_live_report(args))
+        else:
+            report = build_dry_run_report(args)
+    except Exception as exc:
+        print(f"verify_daily_triage: {exc}", file=sys.stderr)
+        return 2
+    print(json.dumps(report, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/activity_core/activities.py

@@ -24,7 +24,12 @@ from activity_core.db import make_engine
 from activity_core.issue_sink import get_issue_sink
 from activity_core.orm import ActivityDefinition as ActivityDefinitionRow
 from activity_core.orm import ActivityRun, TaskInstance, TaskSpawnLog
-from activity_core.rules import evaluate_condition
+from activity_core.llm_client import get_llm_client
+from activity_core.models import InstructionDef
+from activity_core.ops_evidence_sinks import persist_ops_inventory_evidence
+from activity_core.report_sinks import persist_reports
+from activity_core.rules.actions import expand_rule_actions
+from activity_core.rules.executor import execute_instruction_with_audit
 
 
 _session_factory: async_sessionmaker[AsyncSession] | None = None
@@ -98,7 +103,8 @@ async def resolve_context(
     Returns: {bind_key: resolved_value, ...}
 
     Source types are dispatched via CONTEXT_RESOLVER_REGISTRY.
-    A resolver that raises logs a warning and binds {} — it does not abort the run.
+    A resolver that raises logs a warning and binds {} unless the context source
+    is marked required, in which case the activity fails visibly.
     The 'static' type is handled inline without a registry entry.
     """
     import activity_core.context_resolvers  # noqa: F401 — registers all adapters
@@ -109,6 +115,7 @@ async def resolve_context(
         source_type = source.get("type", "")
         query = source.get("query", "")
         params = source.get("params") or {}
+        required = bool(source.get("required") or params.get("required", False))
         raw_bind = source.get("bind_to") or source.get("name") or source_type
         # Strip the 'context.' namespace prefix so evaluator can find the key.
         bind_key = raw_bind.removeprefix("context.") if raw_bind.startswith("context.") else raw_bind
@@ -119,6 +126,11 @@ async def resolve_context(
 
         resolver_cls = CONTEXT_RESOLVER_REGISTRY.get(source_type)
         if resolver_cls is None:
+            if required:
+                raise ApplicationError(
+                    f"Required context source type {source_type!r} is not registered",
+                    non_retryable=True,
+                )
             activity.logger.warning(
                 "Unknown context source type %r — binding {}",
                 source_type,
@@ -129,6 +141,10 @@ async def resolve_context(
         try:
             snapshot[bind_key] = resolver_cls().resolve(query, None, params)
         except Exception as exc:
+            if required:
+                raise ApplicationError(
+                    f"Required context resolver {source_type!r}/{query!r} failed: {exc}"
+                ) from exc
             activity.logger.warning(
                 "Context resolver %r failed — %s; binding {}",
                 source_type,
@@ -226,9 +242,8 @@ async def persist_task_instance(task_payload: dict) -> str:
 
 @activity.defn
 async def evaluate_rules(payload: dict) -> list[dict]:
-    """Evaluate each rule condition against the event and context.
+    """Evaluate rules and render matching actions as task specs.
 
-    Returns the list of matching rule dicts (those whose condition is True).
     Rules that raise UnsafeExpression or any other error are skipped and logged.
 
     Expected keys in payload:
@@ -253,18 +268,99 @@ async def evaluate_rules(payload: dict) -> list[dict]:
 
     event_obj = _Env(event_attrs)
 
-    matched: list[dict] = []
+    task_specs: list[dict] = []
     for rule in rules:
-        condition = rule.get("condition", "")
         try:
-            if evaluate_condition(condition, event_obj, context):
+            task_specs.extend(expand_rule_actions([rule], event_obj, context))
-                matched.append(rule)
         except UnsafeExpression as exc:
             activity.logger.warning("rule %r unsafe expression — skipping: %s", rule.get("id"), exc)
         except Exception as exc:
             activity.logger.warning("rule %r eval error — skipping: %s", rule.get("id"), exc)
 
-    return matched
+    return task_specs
+
+
+@activity.defn
+async def evaluate_instructions(payload: dict) -> dict:
+    """Evaluate instruction blocks and return task specs/reports with audit fields.
+
+    Expected keys in payload:
+        instructions list[dict] — InstructionDef serialised dicts
+        event        dict       — EventEnvelope attributes (or empty for cron)
+        context      dict       — context snapshot from resolve_context
+    """
+    instructions = payload.get("instructions", [])
+    event_attrs = payload.get("event", {})
+    context = payload.get("context", {})
+    llm_client = get_llm_client()
+
+    class _Env:
+        def __init__(self, attrs: dict) -> None:
+            self.attributes = _DictObj(attrs)
+
+    class _DictObj:
+        def __init__(self, d: dict) -> None:
+            self.__dict__.update(d)
+
+    event_obj = _Env(event_attrs)
+
+    task_specs: list[dict] = []
+    reports: list[dict] = []
+    for raw_instruction in instructions:
+        try:
+            instruction = InstructionDef.model_validate(raw_instruction)
+        except Exception as exc:
+            activity.logger.warning("instruction definition invalid — %s", exc)
+            continue
+
+        result = execute_instruction_with_audit(
+            instruction,
+            event_obj,
+            context,
+            llm_client,
+        )
+        if result.report is not None:
+            reports.append({
+                "instruction_id": instruction.id,
+                "report": result.report,
+                "sinks": instruction.report_sinks,
+                "condition": result.condition_matched,
+                "prompt_hash": result.prompt_hash,
+                "model": result.model,
+                "output_validated": result.output_validated,
+                "review_required": result.review_required,
+                "validation_error": result.validation_error,
+            })
+        for spec in result.tasks:
+            task_specs.append({
+                "title": spec.title,
+                "description": spec.description,
+                "target_repo": spec.target_repo,
+                "priority": spec.priority,
+                "labels": spec.labels,
+                "due_in_days": spec.due_in_days,
+                "source_type": "instruction",
+                "source_id": instruction.id,
+                "condition": result.condition_matched,
+                "prompt_hash": result.prompt_hash,
+                "model": result.model,
+                "output_validated": result.output_validated,
+                "review_required": result.review_required,
+            })
+
+    return {"task_specs": task_specs, "reports": reports}
+
+
+@activity.defn
+async def persist_instruction_reports(payload: dict) -> list[dict]:
+    """Persist report payloads to deterministic configured sinks."""
+    return persist_reports(payload)
+
+
+@activity.defn
+async def persist_ops_evidence(payload: dict) -> list[dict]:
+    """Persist compact deterministic ops inventory evidence."""
+    return persist_ops_inventory_evidence(payload)
 
 
 @activity.defn
@@ -289,6 +385,7 @@ async def emit_tasks(payload: dict) -> list[str]:
     Session = _get_session_factory()
 
     refs: list[str] = []
+    errors: list[str] = []
     async with Session() as session:
         async with session.begin():
             for spec_dict in task_specs_raw:
@@ -316,9 +413,18 @@ async def emit_tasks(payload: dict) -> list[str]:
                         triggering_event_id=triggering_event_id,
                         task_ref=ref.external_id,
                         condition_matched=spec_dict.get("condition"),
+                        prompt_hash=spec_dict.get("prompt_hash"),
+                        model=spec_dict.get("model"),
+                        output_validated=spec_dict.get("output_validated"),
+                        review_required=spec_dict.get("review_required"),
                     )
                     session.add(log_row)
                 except Exception as exc:
+                    message = f"{spec.source_type}:{spec.source_id}: {exc}"
+                    errors.append(message)
                     activity.logger.warning("emit_tasks: sink.emit failed — %s", exc)
 
+    if errors:
+        raise RuntimeError(f"task emission sink failure: {errors!r}")
+
     return refs

src/activity_core/api.py

@@ -34,6 +34,7 @@ from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from sqlalchemy import select, text
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from temporalio.api.workflowservice.v1 import GetSystemInfoRequest
 from temporalio.client import Client
 
 from activity_core.models import ActivityDefinition, CronTriggerConfig
@@ -289,7 +290,7 @@ async def health() -> JSONResponse:
         pass
 
     try:
-        await _get_temporal().describe_namespace(TEMPORAL_NAMESPACE)
+        await _get_temporal().workflow_service.get_system_info(GetSystemInfoRequest())
         temporal_ok = True
     except Exception:
         pass

src/activity_core/context_resolvers/__init__.py

@@ -1 +1 @@
-from activity_core.context_resolvers import repo_scoping, state_hub  # noqa: F401
+from activity_core.context_resolvers import ops_inventory, repo_scoping, state_hub  # noqa: F401

src/activity_core/context_resolvers/ops_inventory.py

@@ -0,0 +1,322 @@
+"""Ops service inventory probe context adapter.
+
+Registered as source type ``ops-inventory``.
+
+The resolver reads the Custodian's non-secret service inventory and performs
+bounded HTTP/HTTPS checks for declared endpoints. It deliberately records only
+compact probe metadata: stable inventory ids, sanitized endpoint URLs, status
+codes, boolean match results, and summary counts.
+"""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+import httpx
+import yaml
+
+from activity_core.context_resolvers.base import CONTEXT_RESOLVER_REGISTRY, ContextResolver
+
+_DEFAULT_INVENTORY_PATH = "/home/worsch/the-custodian/ops/service-inventory.yml"
+_DEFAULT_TIMEOUT_SECONDS = 10.0
+_SUPPORTED_ENDPOINT_TYPES = {"http", "https"}
+
+
+class OpsInventoryContextResolver(ContextResolver):
+    """Resolve lightweight ops inventory probes from a non-secret YAML file."""
+
+    def resolve(self, query: str, event: Any, params: dict[str, Any]) -> dict[str, Any]:
+        if query != "probe_services":
+            return {}
+        return _probe_services(params)
+
+
+CONTEXT_RESOLVER_REGISTRY["ops-inventory"] = OpsInventoryContextResolver
+
+
+def _probe_services(params: dict[str, Any]) -> dict[str, Any]:
+    inventory_path = Path(
+        str(
+            params.get("inventory_path")
+            or os.environ.get("OPS_INVENTORY_PATH")
+            or _DEFAULT_INVENTORY_PATH
+        )
+    )
+    timeout_seconds = float(params.get("timeout_seconds", _DEFAULT_TIMEOUT_SECONDS))
+    allow_network = _bool_param(params.get("allow_network", True))
+    required = _bool_param(params.get("required", False))
+    include_kinds = _include_kinds(params.get("include_kinds"))
+
+    if not inventory_path.exists():
+        if required:
+            raise FileNotFoundError(f"ops inventory not found: {inventory_path}")
+        return _empty_result(
+            inventory_path,
+            reason="inventory_not_found",
+            status="skipped",
+            skipped=1,
+        )
+
+    inventory = _load_inventory(inventory_path)
+    raw_services = inventory.get("services")
+    if not isinstance(raw_services, list):
+        if required:
+            raise ValueError("ops inventory missing services list")
+        return _empty_result(
+            inventory_path,
+            reason="invalid_inventory",
+            status="skipped",
+            skipped=1,
+        )
+
+    result = _empty_result(inventory_path)
+    for raw_service in raw_services:
+        if not isinstance(raw_service, dict):
+            continue
+        service = _service_summary(raw_service)
+        result["services"].append(service)
+
+        for endpoint in _endpoint_entries(
+            raw_service,
+            include_kinds,
+            allow_network,
+            timeout_seconds,
+        ):
+            result["endpoints"].append(endpoint)
+            _increment_summary(result["summary"], endpoint["status"])
+
+        for access_path in _access_path_entries(raw_service):
+            result["access_paths"].append(access_path)
+            _increment_summary(result["summary"], access_path["status"])
+
+    return result
+
+
+def _load_inventory(path: Path) -> dict[str, Any]:
+    with path.open("r", encoding="utf-8") as handle:
+        payload = yaml.safe_load(handle) or {}
+    if not isinstance(payload, dict):
+        raise ValueError("ops inventory root must be a mapping")
+    return payload
+
+
+def _empty_result(
+    inventory_path: Path,
+    *,
+    reason: str | None = None,
+    status: str | None = None,
+    skipped: int = 0,
+) -> dict[str, Any]:
+    summary: dict[str, int] = {
+        "ok": 0,
+        "degraded": 0,
+        "down": 0,
+        "skipped": skipped,
+    }
+    result: dict[str, Any] = {
+        "services": [],
+        "endpoints": [],
+        "access_paths": [],
+        "summary": summary,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "inventory_path": str(inventory_path),
+    }
+    if reason is not None:
+        result["reason"] = reason
+    if status is not None:
+        result["status"] = status
+    return result
+
+
+def _service_summary(service: dict[str, Any]) -> dict[str, Any]:
+    endpoints = service.get("endpoints") if isinstance(service.get("endpoints"), list) else []
+    access_paths = (
+        service.get("access_paths") if isinstance(service.get("access_paths"), list) else []
+    )
+    owner_repos = service.get("owner_repos")
+    return {
+        "service_id": str(service.get("id") or ""),
+        "name": str(service.get("name") or service.get("id") or ""),
+        "kind": str(service.get("kind") or ""),
+        "environment": str(service.get("environment") or ""),
+        "lifecycle_state": str(service.get("lifecycle_state") or ""),
+        "declared_health_status": str(service.get("health_status") or ""),
+        "owner_repos": owner_repos if isinstance(owner_repos, list) else [],
+        "endpoint_count": len(endpoints),
+        "access_path_count": len(access_paths),
+    }
+
+
+def _endpoint_entries(
+    service: dict[str, Any],
+    include_kinds: set[str],
+    allow_network: bool,
+    timeout_seconds: float,
+) -> list[dict[str, Any]]:
+    service_id = str(service.get("id") or "")
+    service_name = str(service.get("name") or service_id)
+    raw_endpoints = service.get("endpoints")
+    if not isinstance(raw_endpoints, list):
+        return []
+
+    entries: list[dict[str, Any]] = []
+    for raw_endpoint in raw_endpoints:
+        if not isinstance(raw_endpoint, dict):
+            continue
+        endpoint_type = str(raw_endpoint.get("type") or "").lower()
+        entry = _endpoint_base(service_id, service_name, raw_endpoint, endpoint_type)
+
+        if endpoint_type not in include_kinds:
+            entry.update({"status": "skipped", "reason": "kind_not_included"})
+            entries.append(entry)
+            continue
+        if endpoint_type not in _SUPPORTED_ENDPOINT_TYPES:
+            entry.update({"status": "skipped", "reason": "unsupported_endpoint_type"})
+            entries.append(entry)
+            continue
+        if not raw_endpoint.get("url"):
+            entry.update({"status": "skipped", "reason": "missing_url"})
+            entries.append(entry)
+            continue
+        if not allow_network:
+            entry.update({"status": "skipped", "reason": "network_disabled"})
+            entries.append(entry)
+            continue
+
+        entry.update(_probe_http_endpoint(raw_endpoint, timeout_seconds))
+        entries.append(entry)
+
+    return entries
+
+
+def _endpoint_base(
+    service_id: str,
+    service_name: str,
+    endpoint: dict[str, Any],
+    endpoint_type: str,
+) -> dict[str, Any]:
+    expected_status = endpoint.get("expected_status")
+    return {
+        "service_id": service_id,
+        "service_name": service_name,
+        "endpoint_id": str(endpoint.get("id") or ""),
+        "endpoint_type": endpoint_type,
+        "url": _sanitize_url(str(endpoint.get("url") or "")),
+        "expected_status": expected_status if isinstance(expected_status, int) else None,
+        "expected_signal_present": bool(endpoint.get("expected_signal")),
+        "widget_ref": str(endpoint.get("widget_ref") or ""),
+        "status": "skipped",
+        "reason": None,
+        "status_code": None,
+        "matched_expected_status": None,
+        "matched_expected_signal": None,
+    }
+
+
+def _probe_http_endpoint(
+    endpoint: dict[str, Any],
+    timeout_seconds: float,
+) -> dict[str, Any]:
+    url = str(endpoint.get("url") or "")
+    expected_status = endpoint.get("expected_status")
+    expected_signal = endpoint.get("expected_signal")
+    try:
+        response = httpx.get(url, timeout=timeout_seconds, follow_redirects=False)
+    except httpx.HTTPError as exc:
+        return {
+            "status": "down",
+            "reason": type(exc).__name__,
+            "status_code": None,
+            "matched_expected_status": False if isinstance(expected_status, int) else None,
+            "matched_expected_signal": False if expected_signal else None,
+        }
+
+    status_match = (
+        response.status_code == expected_status
+        if isinstance(expected_status, int)
+        else True
+    )
+    signal_match = (
+        str(expected_signal) in response.text
+        if isinstance(expected_signal, str) and expected_signal
+        else True
+    )
+    status = "ok" if status_match and signal_match else "degraded"
+    reason = None
+    if not status_match:
+        reason = "expected_status_mismatch"
+    elif not signal_match:
+        reason = "expected_signal_missing"
+
+    return {
+        "status": status,
+        "reason": reason,
+        "status_code": response.status_code,
+        "matched_expected_status": status_match,
+        "matched_expected_signal": signal_match,
+    }
+
+
+def _access_path_entries(service: dict[str, Any]) -> list[dict[str, Any]]:
+    service_id = str(service.get("id") or "")
+    service_name = str(service.get("name") or service_id)
+    raw_paths = service.get("access_paths")
+    if not isinstance(raw_paths, list):
+        return []
+
+    entries: list[dict[str, Any]] = []
+    for index, raw_path in enumerate(raw_paths, start=1):
+        if not isinstance(raw_path, dict):
+            continue
+        path_type = str(raw_path.get("type") or "").lower()
+        entries.append({
+            "service_id": service_id,
+            "service_name": service_name,
+            "access_path_id": str(raw_path.get("id") or f"{service_id}-access-{index}"),
+            "access_path_type": path_type,
+            "declared_status": str(raw_path.get("status") or ""),
+            "status": "skipped",
+            "reason": "unsupported_access_path_type",
+        })
+    return entries
+
+
+def _include_kinds(raw: Any) -> set[str]:
+    if raw is None:
+        return set(_SUPPORTED_ENDPOINT_TYPES)
+    if isinstance(raw, str):
+        return {part.strip().lower() for part in raw.split(",") if part.strip()}
+    if isinstance(raw, list):
+        return {str(part).strip().lower() for part in raw if str(part).strip()}
+    return set(_SUPPORTED_ENDPOINT_TYPES)
+
+
+def _bool_param(raw: Any) -> bool:
+    if isinstance(raw, bool):
+        return raw
+    if isinstance(raw, str):
+        return raw.strip().lower() not in {"0", "false", "no", "off"}
+    return bool(raw)
+
+
+def _increment_summary(summary: dict[str, int], status: str) -> None:
+    if status not in summary:
+        status = "skipped"
+    summary[status] += 1
+
+
+def _sanitize_url(raw_url: str) -> str:
+    if not raw_url:
+        return ""
+    parsed = urlsplit(raw_url)
+    if not parsed.scheme or not parsed.netloc:
+        return raw_url.split("?", 1)[0].split("#", 1)[0]
+
+    hostname = parsed.hostname or ""
+    if parsed.port is not None:
+        hostname = f"{hostname}:{parsed.port}"
+    return urlunsplit((parsed.scheme, hostname, parsed.path, "", ""))

src/activity_core/context_resolvers/state_hub.py

@@ -3,7 +3,15 @@
 Registered as source type 'state-hub'.
 Supported queries:
   - domain_summary:   GET {STATE_HUB_URL}/state/domain/{domain}
-  - repo_sbom_status: GET {STATE_HUB_URL}/sbom/status?repo={repo_slug}
+  - repo_sbom_status: single-repo  -> GET {STATE_HUB_URL}/sbom/{repo_slug}
+                      bulk (repos:all) -> GET {STATE_HUB_URL}/repos/
+  - state_summary:    GET {STATE_HUB_URL}/state/summary
+  - next_steps:       GET {STATE_HUB_URL}/state/next_steps
+  - workplan_index:   GET {STATE_HUB_URL}/workstreams/workplan-index
+  - hub_inbox:        GET {STATE_HUB_URL}/messages/?to_agent=hub&unread_only=true
+  - coding_retro:     latest /progress/ item with event_type=coding_retro
+  - daily_triage_digest: curated scalar JSON digest for daily WSJF triage
+  - recently_on_scope_hourly: POST {STATE_HUB_URL}/recently-on-scope/hourly
 
 No caching — state hub data is live operational state and must not be stale
 within a single workflow run.
@@ -12,32 +20,538 @@ Config: STATE_HUB_URL env var (default: http://127.0.0.1:8000).
 
 from __future__ import annotations
 
+import json
 import os
+from datetime import datetime, timezone
 from typing import Any
 
 import httpx
 
 from activity_core.context_resolvers.base import CONTEXT_RESOLVER_REGISTRY, ContextResolver
 
-_STATE_HUB_URL = os.environ.get("STATE_HUB_URL", "http://127.0.0.1:8000")
+_DEFAULT_STATE_HUB_URL = "http://127.0.0.1:8000"
+_TIMEOUT_SECONDS = 10.0
+_OPEN_WORKSTREAM_STATUSES = {"active", "ready", "blocked"}
+_OPEN_TASK_STATUSES = {"wait", "todo", "progress"}
+# Sentinel age for repos that have never had an SBOM ingested. Large enough
+# that any threshold-based staleness rule treats them as "very stale" without
+# forcing the rule expression to special-case None.
+_NEVER_SCANNED_AGE_DAYS = 99999
+
+
+def _base_url() -> str:
+    return os.environ.get("STATE_HUB_URL", _DEFAULT_STATE_HUB_URL).rstrip("/")
+
+
+def _fetch_json(path: str, params: dict[str, Any] | None = None) -> Any:
+    url = f"{_base_url()}{path}"
+    try:
+        resp = httpx.get(url, params=params, timeout=_TIMEOUT_SECONDS)
+        resp.raise_for_status()
+        return resp.json()
+    except (httpx.HTTPError, ValueError):
+        return {}
+
+
+def _post_json(path: str, payload: dict[str, Any]) -> Any:
+    url = f"{_base_url()}{path}"
+    resp = httpx.post(url, json=payload, timeout=_TIMEOUT_SECONDS)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def _validate_recently_on_scope_hourly(result: Any) -> dict[str, Any]:
+    if not isinstance(result, dict):
+        raise RuntimeError("recently_on_scope_hourly returned a non-object response")
+    required_keys = {"generated", "skipped", "failed"}
+    missing = required_keys - set(result)
+    if missing:
+        missing_list = ", ".join(sorted(missing))
+        raise RuntimeError(
+            f"recently_on_scope_hourly response missing required key(s): {missing_list}"
+        )
+    return result
 
 
 class StateHubContextResolver(ContextResolver):
     """Fetches live data from the Custodian State Hub."""
 
-    def resolve(self, query: str, event: Any, params: dict[str, Any]) -> dict[str, Any]:
+    def resolve(self, query: str, event: Any, params: dict[str, Any]) -> Any:
-        base = _STATE_HUB_URL.rstrip("/")
         if query == "domain_summary":
             domain = params.get("domain", "")
-            resp = httpx.get(f"{base}/state/domain/{domain}", timeout=10.0)
+            return _fetch_json(f"/state/domain/{domain}")
-            resp.raise_for_status()
-            return resp.json()
         if query == "repo_sbom_status":
-            repo_slug = params.get("repo_slug", "")
+            return _repo_sbom_status(params)
-            resp = httpx.get(f"{base}/sbom/status", params={"repo": repo_slug}, timeout=10.0)
+        if query == "state_summary":
-            resp.raise_for_status()
+            return _fetch_json("/state/summary")
-            return resp.json()
+        if query == "next_steps":
+            return _fetch_json("/state/next_steps")
+        if query == "workplan_index":
+            query_params = dict(params)
+            return _fetch_json("/workstreams/workplan-index", query_params)
+        if query == "hub_inbox":
+            query_params = {
+                "to_agent": params.get("to_agent", "hub"),
+                "unread_only": params.get("unread_only", True),
+            }
+            return _fetch_json("/messages/", query_params)
+        if query == "coding_retro":
+            return _coding_retro(params)
+        if query == "daily_triage_digest":
+            return _daily_triage_digest(params)
+        if query == "recently_on_scope_hourly":
+            payload = {
+                key: value
+                for key, value in params.items()
+                if key not in {"required"}
+            }
+            result = _post_json("/recently-on-scope/hourly", payload)
+            return _validate_recently_on_scope_hourly(result)
         return {}
 
 
 CONTEXT_RESOLVER_REGISTRY["state-hub"] = StateHubContextResolver
+
+
+def _repo_sbom_status(params: dict[str, Any]) -> dict[str, Any]:
+    """Resolve SBOM staleness against the State Hub.
+
+    Two modes, selected by params:
+
+    - Single-repo: params = {"repo_slug": "<slug>"} -> GET /sbom/{slug}.
+      Returns {repo_slug, last_sbom_at, sbom_age_days, has_sbom}.
+
+    - Bulk: params = {"repos": "all"} -> GET /repos/. Computes age per repo
+      and returns a summary the rule layer can match against without
+      comprehensions (the AST evaluator does not support them):
+        {
+          "repos": [{repo_slug, last_sbom_at, sbom_age_days, has_sbom}, ...],
+          "stale_count": int,
+          "total_count": int,
+          "worst_repo_slug": str | None,
+          "worst_age_days": int | None,
+          "worst_last_sbom_at": str | None,
+        }
+
+    Returns {} on HTTP error to preserve the resolver's graceful-degradation
+    contract.
+    """
+    repo_slug = params.get("repo_slug")
+    bulk = str(params.get("repos", "")).lower() == "all"
+
+    if repo_slug and not bulk:
+        payload = _fetch_json(f"/sbom/{repo_slug}")
+        if not isinstance(payload, dict) or not payload:
+            return {}
+        return _sbom_status_entry(
+            repo_slug=str(payload.get("repo_slug") or repo_slug),
+            last_sbom_at=payload.get("last_sbom_at"),
+        )
+
+    if bulk:
+        repos = _fetch_json("/repos/")
+        if not isinstance(repos, list):
+            return {}
+        entries = [
+            _sbom_status_entry(
+                repo_slug=str(r.get("slug") or ""),
+                last_sbom_at=r.get("last_sbom_at"),
+            )
+            for r in repos
+            if r.get("slug")
+        ]
+        stale = [e for e in entries if e["sbom_age_days"] > 30]
+        worst = max(entries, key=lambda e: e["sbom_age_days"], default=None)
+        # Hoist the worst-repo fields to the top so a sandboxed rule expression
+        # `context.repos.sbom_age_days > 30` matches when any repo is stale,
+        # without needing comprehensions. Bulk-only summary fields live
+        # alongside, and the full per-repo list is exposed under `repos`.
+        result: dict[str, Any] = {
+            "repos": entries,
+            "stale_count": len(stale),
+            "total_count": len(entries),
+            "worst_repo_slug": worst["repo_slug"] if worst else None,
+            "worst_age_days": worst["sbom_age_days"] if worst else None,
+            "worst_last_sbom_at": worst["last_sbom_at"] if worst else None,
+        }
+        if worst:
+            result.update({
+                "repo_slug": worst["repo_slug"],
+                "last_sbom_at": worst["last_sbom_at"],
+                "sbom_age_days": worst["sbom_age_days"],
+                "has_sbom": worst["has_sbom"],
+            })
+        return result
+
+    return {}
+
+
+def _sbom_status_entry(repo_slug: str, last_sbom_at: Any) -> dict[str, Any]:
+    age_days, has_sbom, normalised = _sbom_age_days(last_sbom_at)
+    return {
+        "repo_slug": repo_slug,
+        "last_sbom_at": normalised,
+        "sbom_age_days": age_days,
+        "has_sbom": has_sbom,
+    }
+
+
+def _sbom_age_days(last_sbom_at: Any) -> tuple[int, bool, str | None]:
+    if not isinstance(last_sbom_at, str) or not last_sbom_at:
+        return _NEVER_SCANNED_AGE_DAYS, False, None
+    try:
+        ts = datetime.fromisoformat(last_sbom_at.replace("Z", "+00:00"))
+    except ValueError:
+        return _NEVER_SCANNED_AGE_DAYS, False, last_sbom_at
+    if ts.tzinfo is None:
+        ts = ts.replace(tzinfo=timezone.utc)
+    delta = datetime.now(timezone.utc) - ts
+    return max(0, delta.days), True, last_sbom_at
+
+
+def _coding_retro(params: dict[str, Any]) -> dict[str, Any]:
+    """Return the latest weekly coding-retro read model from State Hub progress.
+
+    Helix Forge publishes this as a `progress` item with event_type=coding_retro.
+    The resolver keeps the workflow-facing shape stable even before the first
+    publication exists, so rules can safely iterate over
+    `context.retro.suggestions`.
+    """
+    event_type = str(params.get("event_type") or "coding_retro")
+    limit = _bounded_int(params.get("limit", 100), default=100, minimum=1, maximum=500)
+    items = _fetch_json("/progress/", {"limit": limit})
+    if not isinstance(items, list):
+        return _empty_coding_retro(event_type)
+
+    item = _latest_progress_item(items, event_type)
+    if item is None:
+        return _empty_coding_retro(event_type)
+
+    detail = _progress_detail(item)
+    return {
+        "suggestions": _normalise_coding_retro_suggestions(
+            detail.get("suggestions")
+        ),
+        "window": _coding_retro_window(detail, params),
+        "generated_at": _string_or_none(
+            detail.get("generated_at") or item.get("created_at")
+        ),
+        "source_progress_id": _string_or_none(item.get("id")),
+        "event_type": event_type,
+        "summary": _short_text(item.get("summary", ""), 200),
+    }
+
+
+def _empty_coding_retro(event_type: str) -> dict[str, Any]:
+    return {
+        "suggestions": [],
+        "window": None,
+        "generated_at": None,
+        "source_progress_id": None,
+        "event_type": event_type,
+        "summary": "",
+    }
+
+
+def _latest_progress_item(
+    items: list[Any],
+    event_type: str,
+) -> dict[str, Any] | None:
+    newest: dict[str, Any] | None = None
+    newest_key: tuple[datetime, int] | None = None
+    for index, item in enumerate(items):
+        if not isinstance(item, dict) or item.get("event_type") != event_type:
+            continue
+        key = (_parse_progress_timestamp(item.get("created_at")), index)
+        if newest_key is None or key > newest_key:
+            newest = item
+            newest_key = key
+    return newest
+
+
+def _parse_progress_timestamp(value: Any) -> datetime:
+    if not isinstance(value, str) or not value:
+        return datetime.min.replace(tzinfo=timezone.utc)
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return datetime.min.replace(tzinfo=timezone.utc)
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _progress_detail(item: dict[str, Any]) -> dict[str, Any]:
+    detail = item.get("detail")
+    if detail is None:
+        detail = item.get("details")
+    if isinstance(detail, str):
+        try:
+            detail = json.loads(detail)
+        except ValueError:
+            return {}
+    if isinstance(detail, dict):
+        return detail
+    return {}
+
+
+def _normalise_coding_retro_suggestions(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    suggestions: list[dict[str, Any]] = []
+    for raw in value:
+        suggestion = _normalise_coding_retro_suggestion(raw)
+        if suggestion is not None:
+            suggestions.append(suggestion)
+    return suggestions
+
+
+def _normalise_coding_retro_suggestion(raw: Any) -> dict[str, Any] | None:
+    if not isinstance(raw, dict):
+        return None
+    repo = _clean_scalar(
+        raw.get("repo") or raw.get("target_repo") or raw.get("repo_slug")
+    )
+    title = _clean_scalar(raw.get("title") or raw.get("summary"))
+    if not repo or not title:
+        return None
+    return {
+        "repo": repo,
+        "title": title,
+        "recommendation": _clean_scalar(
+            raw.get("recommendation") or raw.get("description") or raw.get("body")
+        ),
+        "priority": _normalise_coding_retro_priority(raw.get("priority")),
+        "score": _normalise_score(raw.get("score")),
+    }
+
+
+def _coding_retro_window(
+    detail: dict[str, Any],
+    params: dict[str, Any],
+) -> Any:
+    window = detail.get("window")
+    if window is not None:
+        return window
+    derived = {
+        key: detail.get(key)
+        for key in ("window_start", "window_end", "since", "until")
+        if detail.get(key) is not None
+    }
+    if derived:
+        return derived
+    if params.get("window_days") is not None:
+        return {
+            "days": _bounded_int(
+                params.get("window_days"),
+                default=7,
+                minimum=1,
+                maximum=366,
+            )
+        }
+    return None
+
+
+def _normalise_coding_retro_priority(value: Any) -> str:
+    priority = str(value or "medium").strip().lower()
+    if priority in {"high", "medium", "low"}:
+        return priority
+    return "medium"
+
+
+def _normalise_score(value: Any) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _bounded_int(value: Any, *, default: int, minimum: int, maximum: int) -> int:
+    try:
+        number = int(value)
+    except (TypeError, ValueError):
+        number = default
+    return max(minimum, min(maximum, number))
+
+
+def _clean_scalar(value: Any) -> str:
+    return " ".join(str(value or "").split())
+
+
+def _string_or_none(value: Any) -> str | None:
+    if value is None:
+        return None
+    return str(value)
+
+
+def _daily_triage_digest(params: dict[str, Any]) -> str:
+    """Return a compact JSON string safe to inject into an instruction prompt.
+
+    This is intentionally a scalar string rather than raw State Hub objects.
+    It limits fields to operational identifiers, counts, status, priority, and
+    short titles. That keeps the ActivityDefinition's trusted field small while
+    leaving an explicit `deterministic_scoring` extension point for future
+    code-driven WSJF selection of especially critical/high-gain candidates.
+    """
+    summary = _fetch_json("/state/summary")
+    if not isinstance(summary, dict):
+        return "{}"
+
+    workplan_index = _fetch_json(
+        "/workstreams/workplan-index",
+        {"refresh": params.get("refresh", False)},
+    )
+    if not isinstance(workplan_index, dict):
+        workplan_index = {}
+
+    next_steps = _fetch_json("/state/next_steps")
+    if not isinstance(next_steps, list):
+        next_steps = []
+
+    inbox = _fetch_json(
+        "/messages/",
+        {
+            "to_agent": params.get("to_agent", "hub"),
+            "unread_only": params.get("unread_only", True),
+        },
+    )
+    if not isinstance(inbox, list):
+        inbox = []
+
+    max_workstreams = int(params.get("max_workstreams", 12))
+    max_next_steps = int(params.get("max_next_steps", 8))
+    open_workstreams = _open_workstream_digest(summary, workplan_index, max_workstreams)
+    digest = {
+        "generated_at": summary.get("generated_at"),
+        "totals": summary.get("totals", {}),
+        "open_workstreams": open_workstreams,
+        "next_steps": [_safe_next_step(item) for item in next_steps[:max_next_steps]],
+        "inbox": {
+            "unread_count": len(inbox),
+            "samples": [_safe_inbox_item(item) for item in inbox[:3]],
+        },
+        "deterministic_scoring": {
+            "mode": "candidate_digest_only",
+            "future_mode": "code_score_high_gain_high_effort_candidates",
+            "candidate_fields": [
+                "planning_priority",
+                "status",
+                "open_task_counts",
+                "needs_human_count",
+                "wait_task_count",
+                "workplan_health_labels",
+            ],
+        },
+    }
+    return json.dumps(digest, sort_keys=True, separators=(",", ":"))
+
+
+def _open_workstream_digest(
+    summary: dict[str, Any],
+    workplan_index: dict[str, Any],
+    max_workstreams: int,
+) -> list[dict[str, Any]]:
+    index = workplan_index.get("workstreams") or {}
+    candidates: list[dict[str, Any]] = []
+    for topic in summary.get("topics", []):
+        domain = topic.get("domain_slug") or topic.get("slug")
+        for workstream in topic.get("workstreams", []):
+            if workstream.get("status") not in _OPEN_WORKSTREAM_STATUSES:
+                continue
+            workstream_id = workstream.get("id")
+            detail = _fetch_json(f"/workstreams/{workstream_id}") if workstream_id else {}
+            tasks = _fetch_json("/tasks/", {"workstream_id": workstream_id, "limit": 200})
+            if not isinstance(detail, dict):
+                detail = {}
+            if not isinstance(tasks, list):
+                tasks = []
+            counts = _task_counts(tasks)
+            indexed = index.get(workstream_id, {}) if isinstance(index, dict) else {}
+            candidates.append({
+                "id": workstream_id,
+                "slug": workstream.get("slug"),
+                "title": _short_text(workstream.get("title", ""), 120),
+                "domain": domain,
+                "repo_slug": indexed.get("repo_slug"),
+                "status": workstream.get("status"),
+                "owner": workstream.get("owner"),
+                "planning_priority": detail.get("planning_priority"),
+                "planning_order": detail.get("planning_order"),
+                "file": indexed.get("relative_path"),
+                "needs_review": bool(indexed.get("needs_review", False)),
+                "health_labels": indexed.get("health_labels", []),
+                "open_task_counts": counts,
+                "representative_next_tasks": _representative_tasks(tasks, 3),
+            })
+
+    candidates.sort(key=_candidate_sort_key)
+    return candidates[:max_workstreams]
+
+
+def _task_counts(tasks: list[dict[str, Any]]) -> dict[str, int]:
+    counts = {"wait": 0, "todo": 0, "progress": 0, "needs_human": 0}
+    for task in tasks:
+        status = task.get("status")
+        if status in counts:
+            counts[status] += 1
+        if task.get("needs_human"):
+            counts["needs_human"] += 1
+    counts["open_total"] = counts["wait"] + counts["todo"] + counts["progress"]
+    return counts
+
+
+def _representative_tasks(tasks: list[dict[str, Any]], limit: int) -> list[dict[str, Any]]:
+    open_tasks = [task for task in tasks if task.get("status") in _OPEN_TASK_STATUSES]
+    open_tasks.sort(key=lambda task: (_priority_rank(task.get("priority")), task.get("created_at", "")))
+    return [
+        {
+            "id": task.get("id"),
+            "title": _short_text(task.get("title", ""), 100),
+            "status": task.get("status"),
+            "priority": task.get("priority"),
+            "needs_human": bool(task.get("needs_human", False)),
+        }
+        for task in open_tasks[:limit]
+    ]
+
+
+def _safe_next_step(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "type": item.get("type"),
+        "domain": item.get("domain"),
+        "workstream_id": item.get("workstream_id"),
+        "workstream_slug": item.get("workstream_slug"),
+        "workstream_title": _short_text(item.get("workstream_title", ""), 120),
+        "task_id": item.get("task_id"),
+        "task_title": _short_text(item.get("task_title", ""), 120),
+    }
+
+
+def _safe_inbox_item(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": item.get("id"),
+        "from_agent": item.get("from_agent"),
+        "subject": _short_text(item.get("subject") or item.get("summary") or "", 120),
+        "created_at": item.get("created_at"),
+    }
+
+
+def _candidate_sort_key(candidate: dict[str, Any]) -> tuple[int, int, int, int]:
+    counts = candidate.get("open_task_counts", {})
+    return (
+        _priority_rank(candidate.get("planning_priority")),
+        0 if candidate.get("status") == "active" else 1,
+        -int(counts.get("needs_human", 0)),
+        -int(counts.get("wait", 0)),
+    )
+
+
+def _priority_rank(priority: Any) -> int:
+    return {"high": 0, "medium": 1, "low": 2}.get(str(priority or "").lower(), 3)
+
+
+def _short_text(value: Any, limit: int) -> str:
+    text = " ".join(str(value or "").split())
+    if len(text) <= limit:
+        return text
+    return text[: limit - 1].rstrip() + "…"

src/activity_core/event_type_registry.py

@@ -183,7 +183,7 @@ async def sync_event_types(session_factory: Any) -> int:
                         (type_id, version, publisher, governance, status, attribute_schema, raw_md, synced_at)
                     VALUES
                         (:type_id, :version, :publisher, :governance, :status,
-                         :attribute_schema::jsonb, :raw_md, now())
+                         CAST(:attribute_schema AS jsonb), :raw_md, now())
                     ON CONFLICT (type_id) DO UPDATE SET
                         version = EXCLUDED.version,
                         publisher = EXCLUDED.publisher,

src/activity_core/llm_client.py

@@ -0,0 +1,68 @@
+"""llm-connect adapter for instruction execution.
+
+activity-core deliberately talks to llm-connect over its small HTTP surface
+instead of importing provider-specific SDKs. This keeps the activity worker on
+owned infrastructure while leaving provider selection, API keys, and model
+routing behind the existing llm-connect boundary.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+
+class DisabledLLMClient:
+    """LLM client used when no llm-connect endpoint is configured."""
+
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict[str, Any] | None = None,
+    ) -> str:  # noqa: ARG002
+        raise RuntimeError("LLM_CONNECT_URL is not configured")
+
+
+class LLMConnectClient:
+    """Small synchronous client for llm-connect server mode."""
+
+    def __init__(self, base_url: str, timeout_seconds: float = 300.0) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout_seconds = timeout_seconds
+
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict[str, Any] | None = None,
+    ) -> str:
+        run_config = dict(config or {})
+        if model and "model_name" not in run_config:
+            run_config["model_name"] = model
+        run_config.setdefault("timeout_seconds", int(self.timeout_seconds))
+        payload: dict[str, Any] = {
+            "prompt": prompt,
+            "config": run_config,
+        }
+        resp = httpx.post(
+            f"{self.base_url}/execute",
+            json=payload,
+            timeout=self.timeout_seconds,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        content = data.get("content")
+        if not isinstance(content, str):
+            raise ValueError("llm-connect response missing string content")
+        return content
+
+
+def get_llm_client() -> DisabledLLMClient | LLMConnectClient:
+    base_url = os.environ.get("LLM_CONNECT_URL", "").strip()
+    if not base_url:
+        return DisabledLLMClient()
+    timeout = float(os.environ.get("LLM_CONNECT_TIMEOUT_SECONDS", "300"))
+    return LLMConnectClient(base_url, timeout)

src/activity_core/models.py

@@ -92,6 +92,14 @@ class ActionDef(BaseModel):
 
 class RuleDef(BaseModel):
     id: str
+    for_each: str | None = Field(
+        default=None,
+        description="Optional event/context path to a list for per-item rule expansion.",
+    )
+    bind_as: str = Field(
+        default="item",
+        description="Context key used for each item when for_each is set.",
+    )
     condition: str = Field(
         default="",
         description="Rule DSL expression; empty string means always true.",
@@ -109,9 +117,14 @@ class InstructionDef(BaseModel):
         description="Allowlist of event/context fields that may appear in the prompt template.",
     )
     model: str = Field(description="LLM model identifier, e.g. 'claude-sonnet-4-6'.")
+    temperature: float | None = Field(default=None)
+    max_tokens: int | None = Field(default=None)
+    max_depth: int | None = Field(default=None)
+    model_params: dict[str, Any] = Field(default_factory=dict)
     prompt: str = Field(description="Prompt template with {field.path} placeholders.")
     output_schema: str = Field(description="Path to JSON Schema file for output validation.")
     review_required: bool = Field(default=False)
+    report_sinks: list[dict[str, Any]] = Field(default_factory=list)
 
 
 # ── Context sources ───────────────────────────────────────────────────────────
@@ -119,11 +132,18 @@ class InstructionDef(BaseModel):
 class ContextSource(BaseModel):
     """One external data source that the workflow queries to build the context snapshot."""
 
-    name: str = Field(description="Logical name; referenced as 'context.<name>' in templates.")
+    name: str = Field(
+        default="",
+        description="Logical name; referenced as 'context.<name>' in templates.",
+    )
     type: str = Field(description="Source adapter type: 'repo-scoping' | 'state-hub' | etc.")
     query: str = Field(default="", description="Named query to execute against the source.")
     params: dict[str, Any] = Field(default_factory=dict)
     bind_to: str = Field(default="", description="Context key to bind the result to.")
+    required: bool = Field(
+        default=False,
+        description="When true, resolver failures fail the activity run instead of binding {}.",
+    )
 
 
 # ── Task templates (legacy) ───────────────────────────────────────────────────

src/activity_core/ops_evidence_sinks.py

@@ -0,0 +1,284 @@
+"""Deterministic sinks for ops inventory probe evidence."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from activity_core.context_resolvers.ops_inventory import _sanitize_url
+
+_DEFAULT_STATE_HUB_URL = "http://127.0.0.1:8000"
+_INTER_HUB_SINK_TYPES = {
+    "inter-hub",
+    "inter-hub-event",
+    "inter-hub-interaction-event",
+}
+
+
+def persist_ops_inventory_evidence(payload: dict[str, Any]) -> list[dict[str, Any]]:
+    """Persist compact non-secret ops inventory evidence for configured sources.
+
+    The workflow passes all context sources and the resolved context snapshot.
+    This function filters to ``type: ops-inventory`` sources and only emits
+    evidence when the source params contain an explicit ``evidence_sinks`` list.
+    """
+    results: list[dict[str, Any]] = []
+    for source in payload.get("context_sources", []):
+        if not isinstance(source, dict) or source.get("type") != "ops-inventory":
+            continue
+
+        params = source.get("params") or {}
+        sinks = _normalise_sinks(params.get("evidence_sinks") or params.get("evidence_sink"))
+        if not sinks:
+            continue
+
+        bind_key = _context_bind_key(source)
+        probe_result = (payload.get("context") or {}).get(bind_key)
+        if not isinstance(probe_result, dict):
+            results.extend(
+                {
+                    "type": sink.get("type", "unknown"),
+                    "status": "skipped",
+                    "reason": "missing_probe_result",
+                    "context_key": bind_key,
+                }
+                for sink in sinks
+            )
+            continue
+
+        for sink in sinks:
+            sink_type = sink.get("type")
+            try:
+                if sink_type == "state-hub-progress":
+                    results.append(
+                        _post_state_hub_progress(payload, bind_key, probe_result, sink)
+                    )
+                elif sink_type in _INTER_HUB_SINK_TYPES:
+                    results.append(_inter_hub_result(sink))
+                else:
+                    results.append({
+                        "type": sink_type or "unknown",
+                        "status": "skipped",
+                        "reason": "unknown_sink_type",
+                        "context_key": bind_key,
+                    })
+            except Exception as exc:
+                results.append({
+                    "type": sink_type or "unknown",
+                    "status": "error",
+                    "error": str(exc),
+                    "context_key": bind_key,
+                })
+
+    errors = [result for result in results if result.get("status") == "error"]
+    if errors:
+        raise RuntimeError(f"ops evidence sink failure: {errors!r}")
+    return results
+
+
+def _post_state_hub_progress(
+    payload: dict[str, Any],
+    context_key: str,
+    probe_result: dict[str, Any],
+    sink: dict[str, Any],
+) -> dict[str, Any]:
+    base_url = sink.get("state_hub_url") or os.environ.get("STATE_HUB_URL", _DEFAULT_STATE_HUB_URL)
+    base_url = str(base_url).rstrip("/")
+    event_type = sink.get("event_type", "ops_inventory_probe")
+    run_id = payload["run_id"]
+    idempotency_key = f"{run_id}:{context_key}:{event_type}"
+
+    if _progress_exists(base_url, event_type, idempotency_key):
+        return {
+            "type": "state-hub-progress",
+            "status": "exists",
+            "event_type": event_type,
+            "idempotency_key": idempotency_key,
+            "context_key": context_key,
+        }
+
+    compact = _compact_probe_result(probe_result)
+    body: dict[str, Any] = {
+        "event_type": event_type,
+        "author": sink.get("author", "activity-core"),
+        "summary": _summary_text(compact.get("summary", {})),
+        "detail": {
+            "activity_id": payload.get("activity_id"),
+            "activity_core_run_id": run_id,
+            "scheduled_for": payload.get("scheduled_for"),
+            "source_type": "ops-inventory",
+            "context_key": context_key,
+            "idempotency_key": idempotency_key,
+            "probe": compact,
+        },
+    }
+    for key in ("topic_id", "workstream_id", "task_id", "decision_id"):
+        if sink.get(key):
+            body[key] = sink[key]
+
+    resp = httpx.post(
+        f"{base_url}/progress/",
+        json=body,
+        timeout=float(sink.get("timeout_seconds", 10.0)),
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return {
+        "type": "state-hub-progress",
+        "status": "posted",
+        "event_type": event_type,
+        "progress_id": data.get("id"),
+        "idempotency_key": idempotency_key,
+        "context_key": context_key,
+    }
+
+
+def _progress_exists(base_url: str, event_type: str, idempotency_key: str) -> bool:
+    resp = httpx.get(
+        f"{base_url}/progress/",
+        params={"limit": 100},
+        timeout=10.0,
+    )
+    resp.raise_for_status()
+    for item in resp.json():
+        detail = item.get("detail") or {}
+        if (
+            item.get("event_type") == event_type
+            and detail.get("idempotency_key") == idempotency_key
+        ):
+            return True
+    return False
+
+
+def _inter_hub_result(sink: dict[str, Any]) -> dict[str, Any]:
+    missing: list[str] = []
+    if not (sink.get("inter_hub_url") or os.environ.get("INTER_HUB_URL")):
+        missing.append("INTER_HUB_URL")
+    if not os.environ.get("OPS_HUB_KEY"):
+        missing.append("OPS_HUB_KEY")
+    if not (
+        sink.get("widget_mapping")
+        or sink.get("capability_mapping")
+        or os.environ.get("OPS_HUB_WIDGET_MAPPING")
+    ):
+        missing.append("widget_mapping")
+
+    if missing:
+        return {
+            "type": sink.get("type"),
+            "status": "skipped",
+            "reason": "missing_inter_hub_config",
+            "missing": missing,
+        }
+    return {
+        "type": sink.get("type"),
+        "status": "skipped",
+        "reason": "inter_hub_sink_deferred",
+    }
+
+
+def _compact_probe_result(probe_result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "generated_at": probe_result.get("generated_at"),
+        "inventory_path": probe_result.get("inventory_path"),
+        "status": probe_result.get("status"),
+        "reason": probe_result.get("reason"),
+        "summary": _compact_summary(probe_result.get("summary")),
+        "services": [
+            _compact_service(service)
+            for service in probe_result.get("services", [])
+            if isinstance(service, dict)
+        ],
+        "endpoints": [
+            _compact_endpoint(endpoint)
+            for endpoint in probe_result.get("endpoints", [])
+            if isinstance(endpoint, dict)
+        ],
+        "access_paths": [
+            _compact_access_path(access_path)
+            for access_path in probe_result.get("access_paths", [])
+            if isinstance(access_path, dict)
+        ],
+    }
+
+
+def _compact_summary(raw: Any) -> dict[str, int]:
+    if not isinstance(raw, dict):
+        raw = {}
+    return {
+        "ok": int(raw.get("ok", 0) or 0),
+        "degraded": int(raw.get("degraded", 0) or 0),
+        "down": int(raw.get("down", 0) or 0),
+        "skipped": int(raw.get("skipped", 0) or 0),
+    }
+
+
+def _compact_service(service: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "service_id": service.get("service_id"),
+        "name": service.get("name"),
+        "kind": service.get("kind"),
+        "environment": service.get("environment"),
+        "lifecycle_state": service.get("lifecycle_state"),
+        "declared_health_status": service.get("declared_health_status"),
+        "owner_repos": service.get("owner_repos") if isinstance(service.get("owner_repos"), list) else [],
+        "endpoint_count": service.get("endpoint_count"),
+        "access_path_count": service.get("access_path_count"),
+    }
+
+
+def _compact_endpoint(endpoint: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "service_id": endpoint.get("service_id"),
+        "service_name": endpoint.get("service_name"),
+        "endpoint_id": endpoint.get("endpoint_id"),
+        "endpoint_type": endpoint.get("endpoint_type"),
+        "url": _sanitize_url(str(endpoint.get("url") or "")),
+        "expected_status": endpoint.get("expected_status"),
+        "expected_signal_present": bool(endpoint.get("expected_signal_present")),
+        "widget_ref": endpoint.get("widget_ref"),
+        "status": endpoint.get("status"),
+        "reason": endpoint.get("reason"),
+        "status_code": endpoint.get("status_code"),
+        "matched_expected_status": endpoint.get("matched_expected_status"),
+        "matched_expected_signal": endpoint.get("matched_expected_signal"),
+    }
+
+
+def _compact_access_path(access_path: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "service_id": access_path.get("service_id"),
+        "service_name": access_path.get("service_name"),
+        "access_path_id": access_path.get("access_path_id"),
+        "access_path_type": access_path.get("access_path_type"),
+        "declared_status": access_path.get("declared_status"),
+        "status": access_path.get("status"),
+        "reason": access_path.get("reason"),
+    }
+
+
+def _summary_text(summary: dict[str, Any]) -> str:
+    return (
+        "Ops inventory probe: "
+        f"{summary.get('ok', 0)} ok, "
+        f"{summary.get('degraded', 0)} degraded, "
+        f"{summary.get('down', 0)} down, "
+        f"{summary.get('skipped', 0)} skipped"
+    )
+
+
+def _context_bind_key(source: dict[str, Any]) -> str:
+    raw_bind = source.get("bind_to") or source.get("name") or source.get("type", "")
+    return raw_bind.removeprefix("context.") if raw_bind.startswith("context.") else raw_bind
+
+
+def _normalise_sinks(raw: Any) -> list[dict[str, Any]]:
+    if raw is None:
+        return []
+    if isinstance(raw, dict):
+        return [raw]
+    if isinstance(raw, list):
+        return [sink for sink in raw if isinstance(sink, dict)]
+    return []

src/activity_core/report_sinks.py

@@ -0,0 +1,245 @@
+"""Deterministic sinks for instruction report payloads."""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+import httpx
+
+_DEFAULT_STATE_HUB_URL = "http://127.0.0.1:8000"
+_THE_CUSTODIAN_ROOT = Path("/home/worsch/the-custodian")
+_FORBIDDEN_CUSTODIAN_ROOTS = (
+    _THE_CUSTODIAN_ROOT / "canon",
+    _THE_CUSTODIAN_ROOT / "workplans",
+)
+
+
+def persist_reports(payload: dict[str, Any]) -> list[dict[str, Any]]:
+    """Persist instruction report payloads to configured sinks.
+
+    Raises RuntimeError if any configured sink fails. Successful sinks are
+    idempotent by run_id/date, so Temporal retries can safely replay this
+    activity after a partial failure.
+    """
+    results: list[dict[str, Any]] = []
+    for report_entry in payload.get("reports", []):
+        report_context = dict(report_entry)
+        for sink in report_entry.get("sinks", []):
+            sink_type = sink.get("type")
+            try:
+                if sink_type == "working-memory":
+                    result = _write_working_memory(payload, report_context, sink)
+                    if result.get("path"):
+                        report_context["working_memory_path"] = result["path"]
+                        report_context["working_memory_status"] = result.get("status")
+                    results.append(result)
+                elif sink_type == "state-hub-progress":
+                    results.append(_post_state_hub_progress(payload, report_context, sink))
+                else:
+                    results.append({
+                        "type": sink_type or "unknown",
+                        "status": "skipped",
+                        "reason": "unknown sink type",
+                    })
+            except Exception as exc:
+                results.append({
+                    "type": sink_type or "unknown",
+                    "status": "error",
+                    "error": str(exc),
+                })
+
+    errors = [result for result in results if result.get("status") == "error"]
+    if errors:
+        raise RuntimeError(f"report sink failure: {errors!r}")
+    return results
+
+
+def _write_working_memory(
+    payload: dict[str, Any],
+    report_entry: dict[str, Any],
+    sink: dict[str, Any],
+) -> dict[str, Any]:
+    directory = Path(sink.get("path", "")).expanduser()
+    if not directory:
+        raise ValueError("working-memory sink requires path")
+
+    run_id = payload["run_id"]
+    local_date = _local_date(payload.get("scheduled_for"), sink.get("timezone", "UTC"))
+    instruction_id = report_entry.get("instruction_id", "instruction")
+    filename_template = sink.get(
+        "filename_template",
+        "daily-triage-{date}-{run_id_short}.md",
+    )
+    filename = filename_template.format(
+        date=local_date,
+        run_id=run_id,
+        run_id_short=run_id[:8],
+        instruction_id=instruction_id,
+    )
+    target = (directory / filename).resolve()
+    _assert_allowed_output_path(target)
+
+    if target.exists():
+        text = target.read_text(encoding="utf-8")
+        if f"activity_core_run_id: {run_id}" in text:
+            return {
+                "type": "working-memory",
+                "status": "exists",
+                "path": str(target),
+            }
+        raise FileExistsError(f"refusing to overwrite existing report note: {target}")
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(_render_markdown(payload, report_entry, local_date), encoding="utf-8")
+    return {
+        "type": "working-memory",
+        "status": "written",
+        "path": str(target),
+    }
+
+
+def _post_state_hub_progress(
+    payload: dict[str, Any],
+    report_entry: dict[str, Any],
+    sink: dict[str, Any],
+) -> dict[str, Any]:
+    base_url = sink.get("state_hub_url") or os.environ.get("STATE_HUB_URL", _DEFAULT_STATE_HUB_URL)
+    base_url = str(base_url).rstrip("/")
+    run_id = payload["run_id"]
+    instruction_id = report_entry.get("instruction_id", "")
+    event_type = sink.get("event_type", "daily_triage")
+
+    if _progress_exists(base_url, run_id, instruction_id, event_type):
+        return {
+            "type": "state-hub-progress",
+            "status": "exists",
+            "event_type": event_type,
+        }
+
+    report = report_entry.get("report") or {}
+    body: dict[str, Any] = {
+        "event_type": event_type,
+        "author": sink.get("author", "activity-core"),
+        "summary": report.get("summary", f"Activity report from {instruction_id}"),
+        "detail": {
+            "activity_id": payload.get("activity_id"),
+            "activity_core_run_id": run_id,
+            "instruction_id": instruction_id,
+            "scheduled_for": payload.get("scheduled_for"),
+            "output_validated": report_entry.get("output_validated"),
+            "review_required": report_entry.get("review_required"),
+            "validation_error": report_entry.get("validation_error"),
+            "report": report,
+        },
+    }
+    if report_entry.get("working_memory_path"):
+        body["detail"]["working_memory_path"] = report_entry["working_memory_path"]
+        body["detail"]["working_memory_status"] = report_entry.get(
+            "working_memory_status"
+        )
+    for key in ("topic_id", "workstream_id", "task_id", "decision_id"):
+        if sink.get(key):
+            body[key] = sink[key]
+
+    resp = httpx.post(
+        f"{base_url}/progress/",
+        json=body,
+        timeout=float(sink.get("timeout_seconds", 10.0)),
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return {
+        "type": "state-hub-progress",
+        "status": "posted",
+        "event_type": event_type,
+        "progress_id": data.get("id"),
+    }
+
+
+def _progress_exists(
+    base_url: str,
+    run_id: str,
+    instruction_id: str,
+    event_type: str,
+) -> bool:
+    resp = httpx.get(
+        f"{base_url}/progress/",
+        params={"limit": 100},
+        timeout=10.0,
+    )
+    resp.raise_for_status()
+    for item in resp.json():
+        detail = item.get("detail") or {}
+        if (
+            item.get("event_type") == event_type
+            and detail.get("activity_core_run_id") == run_id
+            and detail.get("instruction_id") == instruction_id
+        ):
+            return True
+    return False
+
+
+def _render_markdown(
+    payload: dict[str, Any],
+    report_entry: dict[str, Any],
+    local_date: str,
+) -> str:
+    report = report_entry.get("report") or {}
+    instruction_id = report_entry.get("instruction_id", "instruction")
+    summary = report.get("summary", "")
+    validation_error = report_entry.get("validation_error")
+    lines = [
+        "---",
+        "type: working-memory",
+        "source: activity-core",
+        f"activity_id: {payload.get('activity_id')}",
+        f"activity_core_run_id: {payload.get('run_id')}",
+        f"instruction_id: {instruction_id}",
+        f"scheduled_for: {payload.get('scheduled_for')}",
+        f"output_validated: {str(bool(report_entry.get('output_validated'))).lower()}",
+        f"review_required: {str(bool(report_entry.get('review_required'))).lower()}",
+        f"model: {report_entry.get('model') or ''}",
+        f"prompt_hash: {report_entry.get('prompt_hash') or ''}",
+        f"created: {datetime.now(tz=timezone.utc).isoformat()}",
+        "---",
+        "",
+        f"# Daily State Hub WSJF Triage - {local_date}",
+        "",
+    ]
+    if summary:
+        lines.extend([summary, ""])
+    if validation_error:
+        lines.extend(["Validation error:", "", f"`{validation_error}`", ""])
+    lines.extend([
+        "```json",
+        json.dumps(report, indent=2, sort_keys=True),
+        "```",
+        "",
+    ])
+    return "\n".join(lines)
+
+
+def _local_date(scheduled_for: str | None, timezone_name: str) -> str:
+    tz = ZoneInfo(timezone_name)
+    if scheduled_for:
+        raw = scheduled_for.replace("Z", "+00:00")
+        dt = datetime.fromisoformat(raw)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+    else:
+        dt = datetime.now(tz=timezone.utc)
+    return dt.astimezone(tz).date().isoformat()
+
+
+def _assert_allowed_output_path(path: Path) -> None:
+    for forbidden in _FORBIDDEN_CUSTODIAN_ROOTS:
+        try:
+            path.relative_to(forbidden)
+        except ValueError:
+            continue
+        raise ValueError(f"refusing to write report into canonical path: {path}")

src/activity_core/rules/actions.py

@@ -0,0 +1,153 @@
+"""Rule action expansion into concrete task specs.
+
+Boundary: no imports from temporalio, sqlalchemy, fastapi, or any
+activity_core.* module outside rules/.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import asdict
+from typing import Any
+
+from activity_core.rules.evaluator import UnsafeExpression, evaluate_condition
+from activity_core.rules.models import TaskSpec
+
+_PLACEHOLDER_RE = re.compile(r"\{([a-zA-Z_][a-zA-Z0-9_.]*)\}")
+_PATH_RE = re.compile(r"^(event|context)(?:\.[a-zA-Z_][a-zA-Z0-9_]*)+$")
+
+
+def expand_rule_actions(rules: list[dict], event: Any, context: dict) -> list[dict]:
+    """Evaluate rule conditions and render matching actions as TaskSpec dicts.
+
+    A rule can opt into per-item expansion with ``for_each``:
+
+        for_each: context.repos.repos
+        bind_as: repo
+
+    Each list item is then available as ``context.repo`` while rendering the
+    condition and action fields. Without ``for_each``, a rule is evaluated once
+    against the original context.
+    """
+    task_specs: list[dict] = []
+    for rule in rules:
+        for bound_context in _iteration_contexts(rule, event, context):
+            if not _condition_matches(rule, event, bound_context):
+                continue
+            task_specs.append(_task_spec_for_rule(rule, event, bound_context))
+    return task_specs
+
+
+def _iteration_contexts(rule: dict, event: Any, context: dict) -> list[dict]:
+    for_each = rule.get("for_each")
+    if not for_each:
+        return [context]
+    if not isinstance(for_each, str) or not _PATH_RE.fullmatch(for_each):
+        raise UnsafeExpression(f"invalid for_each path: {for_each!r}")
+
+    values = _resolve_field(for_each, event, context)
+    if values is None:
+        return []
+    if not isinstance(values, list):
+        raise UnsafeExpression(f"for_each path does not resolve to a list: {for_each!r}")
+
+    bind_as = rule.get("bind_as", "item")
+    if not isinstance(bind_as, str) or not re.fullmatch(r"[a-zA-Z_][a-zA-Z0-9_]*", bind_as):
+        raise UnsafeExpression(f"invalid bind_as name: {bind_as!r}")
+
+    contexts: list[dict] = []
+    for value in values:
+        bound = dict(context)
+        bound[bind_as] = value
+        contexts.append(bound)
+    return contexts
+
+
+def _condition_matches(rule: dict, event: Any, context: dict) -> bool:
+    return evaluate_condition(rule.get("condition", ""), event, context)
+
+
+def _task_spec_for_rule(rule: dict, event: Any, context: dict) -> dict:
+    action = rule.get("action", {})
+    spec = TaskSpec(
+        title=str(_render_value(action.get("task_template", rule.get("id", "")), event, context) or ""),
+        description=str(_render_value(action.get("description", ""), event, context) or ""),
+        target_repo=_string_or_none(_render_value(action.get("target_repo"), event, context)),
+        priority=str(_render_value(action.get("priority", "medium"), event, context) or "medium"),
+        labels=_render_labels(action.get("labels", []), event, context),
+        due_in_days=_int_or_none(_render_value(action.get("due_in_days"), event, context)),
+        source_type="rule",
+        source_id=rule.get("id", ""),
+    )
+    result = asdict(spec)
+    result["condition"] = rule.get("condition", "")
+    return result
+
+
+def _render_labels(value: Any, event: Any, context: dict) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    rendered = []
+    for item in value:
+        rendered_item = _render_value(item, event, context)
+        if rendered_item is not None:
+            rendered.append(str(rendered_item))
+    return rendered
+
+
+def _render_value(value: Any, event: Any, context: dict) -> Any:
+    if isinstance(value, str):
+        if _PATH_RE.fullmatch(value):
+            return _resolve_field(value, event, context)
+        if "{" in value and "}" in value:
+            return _PLACEHOLDER_RE.sub(
+                lambda match: _string_or_empty(
+                    _resolve_field(match.group(1), event, context)
+                ),
+                value,
+            )
+    return value
+
+
+def _resolve_field(field_path: str, event: Any, context: dict) -> Any:
+    if not _PATH_RE.fullmatch(field_path):
+        raise UnsafeExpression(f"invalid field path: {field_path!r}")
+    root, tail = field_path.split(".", 1)
+    if root == "event":
+        return _resolve_path(event, tail)
+    return _resolve_path(context, tail)
+
+
+def _resolve_path(obj: Any, path: str) -> Any:
+    current = obj
+    for part in path.split("."):
+        if current is None:
+            return None
+        if isinstance(current, dict):
+            current = current.get(part)
+        else:
+            current = getattr(current, part, None)
+    return current
+
+
+def _string_or_none(value: Any) -> str | None:
+    if value is None:
+        return None
+    return str(value)
+
+
+def _string_or_empty(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (dict, list)):
+        raise UnsafeExpression("template placeholder resolved to a non-scalar value")
+    return str(value)
+
+
+def _int_or_none(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError) as exc:
+        raise UnsafeExpression(f"field cannot be converted to int: {value!r}") from exc

src/activity_core/rules/executor.py

@@ -11,6 +11,8 @@ import hashlib
 import json
 import logging
 import re
+from dataclasses import dataclass
+from pathlib import Path
 from typing import Any
 
 from activity_core.rules.evaluator import UnsafeExpression, evaluate_condition
@@ -20,12 +22,27 @@ logger = logging.getLogger(__name__)
 
 # Matches {field.path} placeholders in prompt templates.
 _PLACEHOLDER_RE = re.compile(r"\{([a-zA-Z_][a-zA-Z0-9_.]*)\}")
+_FENCED_JSON_RE = re.compile(r"^```(?:json)?\s*(.*?)\s*```\s*$", re.DOTALL)
 
 
 class UntrustedFieldError(ValueError):
     """Raised when a prompt placeholder references a field not in trusted_fields."""
 
 
+@dataclass
+class InstructionResult:
+    """Instruction output plus audit metadata for workflow integration."""
+
+    tasks: list[TaskSpec]
+    report: dict[str, Any] | None = None
+    prompt_hash: str | None = None
+    model: str | None = None
+    output_validated: bool = False
+    review_required: bool = False
+    condition_matched: str | None = None
+    validation_error: str | None = None
+
+
 def _resolve_path(obj: Any, path: str) -> Any:
     """Walk a dot-separated path on obj or dict. Returns None if not found."""
     parts = path.split(".")
@@ -92,14 +109,36 @@ def execute_instruction(
       4. Validate response against instr.output_schema (JSON Schema). Retry once.
       5. Return list[TaskSpec].
     """
+    return execute_instruction_with_audit(instr, event, context, llm_client).tasks
+
+
+def execute_instruction_with_audit(
+    instr: Any,
+    event: Any,
+    context: dict,
+    llm_client: Any,
+) -> InstructionResult:
+    """Evaluate an Instruction and return task specs plus audit metadata."""
     try:
         return _execute(instr, event, context, llm_client)
     except UntrustedFieldError as exc:
         logger.warning("instruction %r rejected — %s", instr.id, exc)
-        return []
+        return _empty_result(instr)
     except Exception as exc:
         logger.warning("instruction %r failed — %s", instr.id, exc)
-        return []
+        failure_report = _execution_failure_report(instr, str(exc))
+        if failure_report is not None:
+            return InstructionResult(
+                tasks=[],
+                report=failure_report,
+                prompt_hash=None,
+                model=getattr(instr, "model", None),
+                output_validated=False,
+                review_required=True,
+                condition_matched=getattr(instr, "condition", "") or None,
+                validation_error=str(exc),
+            )
+        return _empty_result(instr)
 
 
 def _execute(
@@ -107,51 +146,199 @@ def _execute(
     event: Any,
     context: dict,
     llm_client: Any,
-) -> list[TaskSpec]:
+) -> InstructionResult:
     # Step 1 — pre-filter
     try:
         if instr.condition and not evaluate_condition(instr.condition, event, context):
-            return []
+            return _empty_result(instr)
     except UnsafeExpression as exc:
         logger.warning("instruction %r condition is unsafe — %s", instr.id, exc)
-        return []
+        return _empty_result(instr)
 
     # Step 2 — render prompt (raises UntrustedFieldError on policy violation)
     rendered = _render_prompt(instr.prompt, instr.trusted_fields, event, context)
     prompt_hash = hashlib.sha256(rendered.encode()).hexdigest()
+    llm_config = _llm_run_config(instr)
 
     # Step 3 — call LLM
-    raw_output = llm_client.complete(rendered, model=instr.model)
+    raw_output = llm_client.complete(rendered, model=instr.model, config=llm_config)
 
     # Step 4 — validate and optionally retry
-    task_specs, error = _validate_output(raw_output, instr)
+    task_specs, report, error = _validate_output(raw_output, instr)
     if error:
         retry_prompt = rendered + f"\n\nPrevious output was invalid: {error}\nPlease fix."
-        raw_output = llm_client.complete(retry_prompt, model=instr.model)
+        raw_output = llm_client.complete(retry_prompt, model=instr.model, config=llm_config)
-        task_specs, error = _validate_output(raw_output, instr)
+        task_specs, report, error = _validate_output(raw_output, instr)
         if error:
+            # Truncate to keep log volume bounded but long enough to see the
+            # actual JSON shape mismatch (typical reports are <2KB).
+            preview = (raw_output or "")[:2000]
             logger.warning(
-                "instruction_output_error: instruction=%r, prompt_hash=%s, error=%s",
+                "instruction_output_error: instruction=%r, prompt_hash=%s, "
-                instr.id, prompt_hash, error,
+                "error=%s, raw_output_preview=%r",
+                instr.id, prompt_hash, error, preview,
             )
-            return []
+            failure_report = _invalid_output_report(instr, error, raw_output)
+            if failure_report is not None:
+                return InstructionResult(
+                    tasks=[],
+                    report=failure_report,
+                    prompt_hash=prompt_hash,
+                    model=instr.model,
+                    output_validated=False,
+                    review_required=True,
+                    condition_matched=instr.condition or None,
+                    validation_error=error,
+                )
+            return _empty_result(instr, prompt_hash=prompt_hash, validation_error=error)
 
-    return task_specs
+    return InstructionResult(
+        tasks=task_specs,
+        report=report,
+        prompt_hash=prompt_hash,
+        model=instr.model,
+        output_validated=True,
+        review_required=bool(getattr(instr, "review_required", False)),
+        condition_matched=instr.condition or None,
+    )
 
 
-def _validate_output(raw_output: Any, instr: Any) -> tuple[list[TaskSpec], str | None]:
+def _llm_run_config(instr: Any) -> dict[str, Any]:
-    """Parse raw LLM output into TaskSpec list. Returns (specs, error_message)."""
+    """Build the llm-connect RunConfig payload from instruction metadata."""
+    config: dict[str, Any] = {"model_name": instr.model}
+    for field in ("temperature", "max_tokens", "max_depth"):
+        value = getattr(instr, field, None)
+        if value is not None:
+            config[field] = value
+    model_params = dict(getattr(instr, "model_params", None) or {})
+    schema = _load_output_schema(getattr(instr, "output_schema", ""))
+    if schema is not None:
+        model_params.setdefault("json_schema", schema)
+    if model_params:
+        config["model_params"] = model_params
+    return config
+
+
+def _empty_result(
+    instr: Any,
+    prompt_hash: str | None = None,
+    validation_error: str | None = None,
+) -> InstructionResult:
+    return InstructionResult(
+        tasks=[],
+        prompt_hash=prompt_hash,
+        model=getattr(instr, "model", None),
+        output_validated=False,
+        review_required=bool(getattr(instr, "review_required", False)),
+        condition_matched=getattr(instr, "condition", "") or None,
+        validation_error=validation_error,
+    )
+
+
+def _invalid_output_report(
+    instr: Any,
+    validation_error: str,
+    raw_output: Any,
+) -> dict[str, Any] | None:
+    """Build a durable diagnostic report for invalid report-sink output.
+
+    Task-only instructions keep the legacy empty-result behavior. Instructions
+    with report sinks should leave operators a bounded artifact that preserves
+    the partial model output without marking it as schema-valid.
+    """
+    if not getattr(instr, "report_sinks", None):
+        return None
+
+    partial_output: Any
+    raw_preview: str | None = None
+    if isinstance(raw_output, str):
+        try:
+            partial_output = _parse_json_output(raw_output)
+        except json.JSONDecodeError:
+            partial_output = None
+            raw_preview = raw_output[:4000]
+    else:
+        partial_output = raw_output
+
+    report: dict[str, Any] = {
+        "summary": (
+            f"Instruction {instr.id} produced output that failed validation; "
+            "partial output was preserved for operator review."
+        ),
+        "status": "validation_failed",
+        "validation_error": validation_error,
+    }
+    if isinstance(partial_output, dict):
+        if isinstance(partial_output.get("summary"), str):
+            report["partial_summary"] = partial_output["summary"]
+        report["partial_report"] = partial_output
+    elif isinstance(partial_output, list):
+        report["partial_report"] = partial_output
+    elif raw_preview is not None:
+        report["raw_output_preview"] = raw_preview
+    return report
+
+
+def _execution_failure_report(instr: Any, error: str) -> dict[str, Any] | None:
+    """Build a durable diagnostic report when a report instruction cannot run."""
+    if not getattr(instr, "report_sinks", None):
+        return None
+    return {
+        "summary": (
+            f"Instruction {instr.id} could not run; operator review is required."
+        ),
+        "status": "execution_failed",
+        "validation_error": error,
+    }
+
+
+def _validate_output(
+    raw_output: Any,
+    instr: Any,
+) -> tuple[list[TaskSpec], dict[str, Any] | None, str | None]:
+    """Parse raw LLM output into TaskSpecs and optional report payload.
+
+    Accepted shapes:
+      - list[task]
+      - single task dict with title/description/etc.
+      - {"tasks": [...], "report": {...}}
+      - report-only dict, such as {"summary": "...", "recommendations": [...]}
+
+    Returns (specs, report, error_message).
+    """
     try:
         if isinstance(raw_output, str):
-            data = json.loads(raw_output)
+            data = _parse_json_output(raw_output)
         else:
             data = raw_output
 
-        if not isinstance(data, list):
+        schema_error = _validate_against_schema(data, getattr(instr, "output_schema", ""))
-            data = [data]
+        if schema_error:
+            return [], None, schema_error
+
+        report: dict[str, Any] | None = None
+        task_items: list[Any]
+        if isinstance(data, dict) and ("tasks" in data or "report" in data):
+            maybe_report = data.get("report")
+            if maybe_report is not None and not isinstance(maybe_report, dict):
+                return [], None, "report must be a JSON object"
+            report = maybe_report
+            tasks = data.get("tasks", [])
+            if not isinstance(tasks, list):
+                return [], None, "tasks must be a JSON array"
+            task_items = tasks
+        elif isinstance(data, dict) and "title" not in data:
+            report = data
+            task_items = []
+        elif isinstance(data, list):
+            task_items = data
+        else:
+            task_items = [data]
 
         specs = []
-        for item in data:
+        for item in task_items:
+            if not isinstance(item, dict):
+                return [], None, "each task must be a JSON object"
             specs.append(TaskSpec(
                 title=item.get("title", ""),
                 description=item.get("description", ""),
@@ -162,6 +349,110 @@ def _validate_output(raw_output: Any, instr: Any) -> tuple[list[TaskSpec], str |
                 source_type="instruction",
                 source_id=instr.id,
             ))
-        return specs, None
+        return specs, report, None
     except (json.JSONDecodeError, AttributeError, KeyError, TypeError) as exc:
-        return [], str(exc)
+        return [], None, str(exc)
+
+
+def _parse_json_output(raw_output: str) -> Any:
+    """Parse JSON output, accepting a single Markdown JSON fence when present."""
+    text = raw_output.strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError as original_error:
+        fence_match = _FENCED_JSON_RE.match(text)
+        if fence_match:
+            return json.loads(fence_match.group(1).strip())
+
+        decoder = json.JSONDecoder()
+        for marker in ("{", "["):
+            start = text.find(marker)
+            if start < 0:
+                continue
+            try:
+                data, _ = decoder.raw_decode(text[start:])
+            except json.JSONDecodeError:
+                continue
+            return data
+        raise original_error
+
+
+def _validate_against_schema(data: Any, schema_path: str) -> str | None:
+    if not schema_path:
+        return None
+
+    try:
+        schema = _load_output_schema(schema_path)
+    except (OSError, json.JSONDecodeError, TypeError) as exc:
+        return f"could not read output schema: {exc}"
+    if schema is None:
+        return None
+
+    return _validate_schema_node(data, schema, "$")
+
+
+def _load_output_schema(schema_path: str) -> dict[str, Any] | None:
+    """Load a JSON schema file when present.
+
+    Missing schema files are intentionally tolerated for backward
+    compatibility with existing tests and definitions.
+    """
+    if not schema_path:
+        return None
+
+    path = Path(schema_path)
+    if not path.exists():
+        return None
+
+    schema = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(schema, dict):
+        raise TypeError("output schema must be a JSON object")
+    return schema
+
+
+def _validate_schema_node(data: Any, schema: dict[str, Any], path: str) -> str | None:
+    expected_type = schema.get("type")
+    if expected_type and not _matches_type(data, expected_type):
+        return f"{path}: expected {expected_type}"
+
+    if expected_type == "object":
+        required = schema.get("required", [])
+        if isinstance(required, list):
+            for key in required:
+                if isinstance(key, str) and key not in data:
+                    return f"{path}: missing required property {key!r}"
+        properties = schema.get("properties", {})
+        if isinstance(properties, dict):
+            for key, child_schema in properties.items():
+                if key in data and isinstance(child_schema, dict):
+                    error = _validate_schema_node(data[key], child_schema, f"{path}.{key}")
+                    if error:
+                        return error
+
+    if expected_type == "array":
+        item_schema = schema.get("items")
+        if isinstance(item_schema, dict):
+            for index, item in enumerate(data):
+                error = _validate_schema_node(item, item_schema, f"{path}[{index}]")
+                if error:
+                    return error
+
+    return None
+
+
+def _matches_type(data: Any, expected_type: str) -> bool:
+    if expected_type == "object":
+        return isinstance(data, dict)
+    if expected_type == "array":
+        return isinstance(data, list)
+    if expected_type == "string":
+        return isinstance(data, str)
+    if expected_type == "integer":
+        return isinstance(data, int) and not isinstance(data, bool)
+    if expected_type == "number":
+        return isinstance(data, (int, float)) and not isinstance(data, bool)
+    if expected_type == "boolean":
+        return isinstance(data, bool)
+    if expected_type == "null":
+        return data is None
+    return True

src/activity_core/schedule_manager.py

@@ -51,6 +51,11 @@ def schedule_id(activity_id: str | UUID) -> str:
     return f"activity-schedule-{activity_id}"
 
 
+def smoke_schedule_id(activity_id: str | UUID) -> str:
+    """Return the one-shot smoke-test Schedule ID for an ActivityDefinition."""
+    return f"activity-smoke-test-{activity_id}"
+
+
 def _overlap_policy(misfire_policy: str) -> ScheduleOverlapPolicy:
     return _MISFIRE_TO_OVERLAP.get(misfire_policy, ScheduleOverlapPolicy.SKIP)
 
@@ -128,6 +133,55 @@ def _build_onetime_schedule(defn: ActivityDefinition) -> tuple[str, Schedule]:
     return sid, Schedule(action=action, spec=spec, state=state)
 
 
+def _build_smoke_test_schedule(
+    defn: ActivityDefinition,
+    fire_at: datetime,
+) -> tuple[str, str, Schedule]:
+    """Build a one-shot smoke Schedule for an enabled cron ActivityDefinition."""
+    if not isinstance(defn.trigger_config, CronTriggerConfig):
+        raise ValueError("schedule smoke tests require trigger_type='cron'")
+    if not defn.enabled:
+        raise ValueError("schedule smoke tests require an enabled ActivityDefinition")
+
+    at = fire_at.astimezone(timezone.utc)
+    token = at.strftime("%Y%m%dT%H%M%SZ")
+    workflow_id_prefix = f"activity-{defn.id}:smoke-{token}"
+    trigger_key = f"schedule-smoke-{token}"
+
+    action = ScheduleActionStartWorkflow(
+        "RunActivityWorkflow",
+        args=[str(defn.id), trigger_key, at.isoformat(), None],
+        id=workflow_id_prefix,
+        task_queue=_ORCHESTRATOR_TASK_QUEUE,
+    )
+
+    spec = ScheduleSpec(
+        calendars=[
+            ScheduleCalendarSpec(
+                second=[ScheduleRange(at.second)],
+                minute=[ScheduleRange(at.minute)],
+                hour=[ScheduleRange(at.hour)],
+                day_of_month=[ScheduleRange(at.day)],
+                month=[ScheduleRange(at.month)],
+                year=[ScheduleRange(at.year)],
+            )
+        ],
+        time_zone_name="UTC",
+    )
+
+    state = ScheduleState(
+        limited_actions=True,
+        remaining_actions=1,
+        paused=False,
+    )
+
+    return (
+        smoke_schedule_id(defn.id),
+        workflow_id_prefix,
+        Schedule(action=action, spec=spec, state=state),
+    )
+
+
 async def cancel_scheduled(client: Client, activity_id: str | UUID) -> None:
     """Delete the one-off Temporal Schedule for a ScheduledTriggerConfig definition.
 
@@ -140,6 +194,45 @@ async def cancel_scheduled(client: Client, activity_id: str | UUID) -> None:
         pass
 
 
+async def schedule_smoke_test(
+    client: Client,
+    defn: ActivityDefinition,
+    *,
+    delay: timedelta = timedelta(minutes=1),
+    now: datetime | None = None,
+) -> tuple[str, str, datetime]:
+    """Schedule a one-shot smoke run for a recurring ActivityDefinition.
+
+    Returns ``(schedule_id, workflow_id_prefix, fire_at)``. Temporal appends
+    the scheduled fire time to workflow IDs created by schedules.
+    """
+    base = now or datetime.now(tz=timezone.utc)
+    if base.tzinfo is None:
+        base = base.replace(tzinfo=timezone.utc)
+    fire_at = (base + delay).astimezone(timezone.utc)
+    sid, workflow_id_prefix, sched = _build_smoke_test_schedule(defn, fire_at)
+    try:
+        await client.create_schedule(sid, sched)
+    except (RPCError, ScheduleAlreadyRunningError):
+        handle = client.get_schedule_handle(sid)
+
+        async def _updater_smoke(inp: ScheduleUpdateInput) -> ScheduleUpdate:  # noqa: ARG001
+            return ScheduleUpdate(schedule=sched)
+
+        await handle.update(_updater_smoke)
+        await handle.unpause()
+    return sid, workflow_id_prefix, fire_at
+
+
+async def delete_smoke_test_schedule(client: Client, activity_id: str | UUID) -> None:
+    """Delete the smoke-test Schedule for the given activity_id if present."""
+    handle = client.get_schedule_handle(smoke_schedule_id(activity_id))
+    try:
+        await handle.delete()
+    except RPCError:
+        pass
+
+
 async def upsert_schedule(client: Client, defn: ActivityDefinition) -> ScheduleHandle:
     """Create or update a Temporal Schedule for a cron or scheduled ActivityDefinition.
 

src/activity_core/sync_activity_definitions.py

@@ -18,7 +18,7 @@ import logging
 import os
 import uuid
 
-from sqlalchemy import select, text
+from sqlalchemy import update
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
@@ -28,6 +28,21 @@ from activity_core.orm import ActivityDefinition as ActivityDefinitionRow
 logger = logging.getLogger(__name__)
 
 TEMPORAL_HOST = os.environ.get("TEMPORAL_HOST", "localhost:7233")
+ACTIVITY_DEFINITION_ID_NAMESPACE = uuid.uuid5(
+    uuid.NAMESPACE_URL,
+    "activity-core:activity-definition",
+)
+
+
+def _definition_uuid(raw_id: str) -> uuid.UUID:
+    """Return the DB UUID for a file-authored ActivityDefinition id."""
+    try:
+        return uuid.UUID(raw_id)
+    except ValueError:
+        return uuid.uuid5(
+            ACTIVITY_DEFINITION_ID_NAMESPACE,
+            raw_id,
+        )
 
 
 async def sync(session_factory: async_sessionmaker[AsyncSession]) -> int:
@@ -43,11 +58,12 @@ async def sync(session_factory: async_sessionmaker[AsyncSession]) -> int:
     async with session_factory() as session:
         async with session.begin():
             for d in defs:
-                file_ids.add(d.id)
+                definition_id = _definition_uuid(d.id)
+                file_ids.add(str(definition_id))
                 stmt = (
                     pg_insert(ActivityDefinitionRow)
                     .values(
-                        id=uuid.UUID(d.id),
+                        id=definition_id,
                         name=d.name,
                         enabled=d.enabled,
                         trigger_type=d.trigger_config["trigger_type"],
@@ -80,14 +96,13 @@ async def sync(session_factory: async_sessionmaker[AsyncSession]) -> int:
             if file_ids:
                 id_list = [uuid.UUID(i) for i in file_ids]
                 await session.execute(
-                    text(
+                    update(ActivityDefinitionRow)
-                        "UPDATE activity_definitions SET enabled = false"
+                    .where(ActivityDefinitionRow.id.not_in(id_list))
-                        " WHERE id NOT IN :ids"
+                    .values(enabled=False)
-                    ).bindparams(ids=tuple(id_list))
                 )
             else:
                 await session.execute(
-                    text("UPDATE activity_definitions SET enabled = false")
+                    update(ActivityDefinitionRow).values(enabled=False)
                 )
 
     logger.info("sync_activity_definitions: upserted %d definitions", upserted)

src/activity_core/worker.py

@@ -34,10 +34,13 @@ from temporalio.worker import Worker
 
 from activity_core.activities import (
     emit_tasks,
+    evaluate_instructions,
     evaluate_rules,
     init_session_factory,
     load_activity_definition,
     log_run,
+    persist_instruction_reports,
+    persist_ops_evidence,
     persist_task_instance,
     resolve_context,
 )
@@ -93,7 +96,16 @@ async def run() -> None:
         client,
         task_queue=ORCHESTRATOR_TASK_QUEUE,
         workflows=[RunActivityWorkflow],
-        activities=[load_activity_definition, resolve_context, log_run, evaluate_rules, emit_tasks],
+        activities=[
+            load_activity_definition,
+            resolve_context,
+            log_run,
+            evaluate_rules,
+            evaluate_instructions,
+            persist_instruction_reports,
+            persist_ops_evidence,
+            emit_tasks,
+        ],
     )
 
     task_worker = Worker(

src/activity_core/workflows.py

@@ -11,6 +11,7 @@ Workflow IDs follow the conventions in docs/conventions.md:
 
 from __future__ import annotations
 
+import os
 import uuid
 from datetime import timedelta
 
@@ -21,8 +22,11 @@ with workflow.unsafe.imports_passed_through():
     from activity_core.activities import (
         emit_tasks,
         evaluate_rules,
+        evaluate_instructions,
         load_activity_definition,
         log_run,
+        persist_instruction_reports,
+        persist_ops_evidence,
         persist_task_instance,
         resolve_context,
     )
@@ -40,7 +44,9 @@ _RETRY_POLICY = RetryPolicy(
     maximum_attempts=10,
 )
 
-_ACTIVITY_TIMEOUT = timedelta(minutes=5)
+_ACTIVITY_TIMEOUT = timedelta(
+    seconds=int(os.environ.get("ACTIVITY_TIMEOUT_SECONDS", "900"))
+)
 _TASK_QUEUE = "task-execution-tq"
 
 
@@ -100,6 +106,26 @@ class RunActivityWorkflow:
             retry_policy=_RETRY_POLICY,
         )
 
+        if trigger_key == SCHEDULED_TRIGGER_KEY:
+            dedup_source = workflow.info().workflow_id
+        else:
+            dedup_source = f"{activity_id}:{trigger_key}"
+        run_id = str(uuid.uuid5(uuid.NAMESPACE_URL, dedup_source))
+
+        await workflow.execute_activity(
+            persist_ops_evidence,
+            {
+                "context_sources": defn.get("context_sources", []),
+                "context": context_snapshot,
+                "activity_id": activity_id,
+                "run_id": run_id,
+                "scheduled_for": scheduled_for,
+                "version_used": defn["version"],
+            },
+            start_to_close_timeout=_ACTIVITY_TIMEOUT,
+            retry_policy=_RETRY_POLICY,
+        )
+
         # ── 3. Evaluate rules ─────────────────────────────────────────────────
         import json as _json
         event_attrs: dict = {}
@@ -109,7 +135,7 @@ class RunActivityWorkflow:
             except Exception:
                 pass
 
-        matched_rules: list[dict] = await workflow.execute_activity(
+        task_spec_dicts: list[dict] = await workflow.execute_activity(
             evaluate_rules,
             {
                 "rules": defn.get("rules", []),
@@ -120,28 +146,35 @@ class RunActivityWorkflow:
             retry_policy=_RETRY_POLICY,
         )
 
-        # Convert matched rules to TaskSpec dicts for emission.
+        report_dicts: list[dict] = []
-        task_spec_dicts: list[dict] = []
+        if defn.get("instructions"):
-        for rule in matched_rules:
+            instruction_result: dict = await workflow.execute_activity(
-            action = rule.get("action", {})
+                evaluate_instructions,
-            task_spec_dicts.append({
+                {
-                "title": action.get("task_template", rule.get("id", "")),
+                    "instructions": defn.get("instructions", []),
-                "description": "",
+                    "event": event_attrs,
-                "target_repo": action.get("target_repo"),
+                    "context": context_snapshot,
-                "priority": action.get("priority", "medium"),
+                },
-                "labels": action.get("labels", []),
+                start_to_close_timeout=_ACTIVITY_TIMEOUT,
-                "due_in_days": action.get("due_in_days"),
+                retry_policy=_RETRY_POLICY,
-                "source_type": "rule",
+            )
-                "source_id": rule.get("id", ""),
+            task_spec_dicts.extend(instruction_result.get("task_specs", []))
-                "condition": rule.get("condition", ""),
+            report_dicts.extend(instruction_result.get("reports", []))
-            })
 
-        # ── 4. Emit tasks via IssueSink ───────────────────────────────────────
+        # ── 4. Persist reports and emit tasks ────────────────────────────────
-        if trigger_key == SCHEDULED_TRIGGER_KEY:
+        if report_dicts:
-            dedup_source = workflow.info().workflow_id
+            await workflow.execute_activity(
-        else:
+                persist_instruction_reports,
-            dedup_source = f"{activity_id}:{trigger_key}"
+                {
-        run_id = str(uuid.uuid5(uuid.NAMESPACE_URL, dedup_source))
+                    "reports": report_dicts,
+                    "activity_id": activity_id,
+                    "run_id": run_id,
+                    "scheduled_for": scheduled_for,
+                    "version_used": defn["version"],
+                },
+                start_to_close_timeout=_ACTIVITY_TIMEOUT,
+                retry_policy=_RETRY_POLICY,
+            )
 
         if task_spec_dicts:
             await workflow.execute_activity(

tests/rules/test_actions.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import pytest
+
+from activity_core.rules.actions import expand_rule_actions
+from activity_core.rules.evaluator import UnsafeExpression
+
+
+class _Attrs:
+    def __init__(self, **kw):
+        for k, v in kw.items():
+            setattr(self, k, v)
+
+
+class _Event:
+    def __init__(self, **attrs):
+        self.attributes = _Attrs(**attrs)
+
+
+def test_action_field_path_interpolation_resolves_context_value() -> None:
+    rules = [
+        {
+            "id": "flag-stale-sbom",
+            "condition": "context.repos.sbom_age_days > 30",
+            "action": {
+                "task_template": "Run SBOM rescan for {context.repos.repo_slug}",
+                "target_repo": "context.repos.repo_slug",
+                "priority": "medium",
+                "labels": ["sbom", "{context.repos.repo_slug}"],
+            },
+        }
+    ]
+
+    specs = expand_rule_actions(
+        rules,
+        _Event(),
+        {"repos": {"repo_slug": "activity-core", "sbom_age_days": 45}},
+    )
+
+    assert specs == [
+        {
+            "title": "Run SBOM rescan for activity-core",
+            "description": "",
+            "target_repo": "activity-core",
+            "priority": "medium",
+            "labels": ["sbom", "activity-core"],
+            "due_in_days": None,
+            "source_type": "rule",
+            "source_id": "flag-stale-sbom",
+            "triggering_event_id": "",
+            "activity_definition_id": "",
+            "condition": "context.repos.sbom_age_days > 30",
+        }
+    ]
+
+
+def test_for_each_binds_each_list_item_before_condition_and_action_rendering() -> None:
+    rules = [
+        {
+            "id": "flag-stale-sbom",
+            "for_each": "context.repos.repos",
+            "bind_as": "repo",
+            "condition": "context.repo.sbom_age_days > 30",
+            "action": {
+                "task_template": "Run SBOM rescan for {context.repo.repo_slug}",
+                "target_repo": "context.repo.repo_slug",
+                "priority": "medium",
+                "labels": ["sbom", "security", "automated"],
+            },
+        }
+    ]
+    context = {
+        "repos": {
+            "repos": [
+                {"repo_slug": "repo-a", "sbom_age_days": 60},
+                {"repo_slug": "repo-b", "sbom_age_days": 10},
+                {"repo_slug": "repo-c", "sbom_age_days": 45},
+            ]
+        }
+    }
+
+    specs = expand_rule_actions(rules, _Event(), context)
+
+    assert [spec["target_repo"] for spec in specs] == ["repo-a", "repo-c"]
+    assert [spec["title"] for spec in specs] == [
+        "Run SBOM rescan for repo-a",
+        "Run SBOM rescan for repo-c",
+    ]
+
+
+def test_for_each_rejects_non_path_expression() -> None:
+    rules = [
+        {
+            "id": "bad",
+            "for_each": "__import__('os')",
+            "condition": "",
+            "action": {"task_template": "bad"},
+        }
+    ]
+
+    with pytest.raises(UnsafeExpression):
+        expand_rule_actions(rules, _Event(), {})
+
+
+def test_template_placeholder_rejects_non_scalar_values() -> None:
+    rules = [
+        {
+            "id": "bad",
+            "condition": "",
+            "action": {
+                "task_template": "Run {context.repos}",
+            },
+        }
+    ]
+
+    with pytest.raises(UnsafeExpression):
+        expand_rule_actions(rules, _Event(), {"repos": [{"repo_slug": "repo-a"}]})

tests/rules/test_executor.py

@@ -4,7 +4,8 @@ Covers:
 - UntrustedFieldError raised when prompt references untrusted field
 - Object-type attribute rejected even when listed in trusted_fields
 - Injection fixture: untrusted field raises UntrustedFieldError before rendering
-- Schema validation: NullLLM returning invalid JSON → retry → second invalid → []
+- Schema validation: invalid JSON retries once; report-sink instructions preserve
+  a validation-failure artifact after the second invalid output.
 - review_required flag: present on InstructionDef model
 """
 
@@ -21,6 +22,7 @@ from activity_core.rules.executor import (
     UntrustedFieldError,
     _render_prompt,
     execute_instruction,
+    execute_instruction_with_audit,
 )
 
 
@@ -29,26 +31,55 @@ from activity_core.rules.executor import (
 class _NullLLM:
     """Always returns an empty task list."""
 
-    def complete(self, prompt: str, model: str = "") -> str:
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict | None = None,
+    ) -> str:
         return "[]"
 
 
 class _BadLLM:
     """Returns invalid JSON on every call."""
 
-    def complete(self, prompt: str, model: str = "") -> str:
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict | None = None,
+    ) -> str:
         return "not valid json {"
 
 
+class _FailingLLM:
+    """Raises like a missing or unreachable llm-connect endpoint."""
+
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict | None = None,
+    ) -> str:
+        raise RuntimeError("LLM_CONNECT_URL is not configured")
+
+
 class _CountingLLM:
     """Tracks how many times complete() is called; returns bad JSON then good JSON."""
 
     def __init__(self, responses: list[str]) -> None:
         self._responses = list(responses)
         self.call_count = 0
+        self.calls: list[dict | None] = []
 
-    def complete(self, prompt: str, model: str = "") -> str:
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict | None = None,
+    ) -> str:
         self.call_count += 1
+        self.calls.append(config)
         if self._responses:
             return self._responses.pop(0)
         return "[]"
@@ -76,6 +107,11 @@ def _instr(
     model: str = "claude-sonnet-4-6",
     output_schema: str = "",
     review_required: bool = False,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+    max_depth: int | None = None,
+    model_params: dict[str, Any] | None = None,
+    report_sinks: list[dict[str, Any]] | None = None,
 ) -> SimpleNamespace:
     return SimpleNamespace(
         id=id,
@@ -83,8 +119,13 @@ def _instr(
         trusted_fields=trusted_fields or [],
         prompt=prompt,
         model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_depth=max_depth,
+        model_params=model_params or {},
         output_schema=output_schema,
         review_required=review_required,
+        report_sinks=report_sinks or [],
     )
 
 
@@ -201,6 +242,244 @@ def test_valid_llm_output_returns_task_spec():
     assert result[0].source_type == "instruction"
 
 
+def test_execute_instruction_with_audit_returns_metadata():
+    task_data = [{"title": "Run triage", "priority": "high"}]
+    llm = _CountingLLM([json.dumps(task_data)])
+    instr = _instr(
+        id="daily-triage",
+        condition="",
+        prompt="Check State Hub.",
+        trusted_fields=[],
+        model="test-model",
+        review_required=True,
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert len(result.tasks) == 1
+    assert result.tasks[0].source_id == "daily-triage"
+    assert result.prompt_hash is not None
+    assert len(result.prompt_hash) == 64
+    assert result.model == "test-model"
+    assert result.output_validated is True
+    assert result.review_required is True
+
+
+def test_execute_instruction_forwards_llm_connect_run_config():
+    llm = _CountingLLM(["[]"])
+    instr = _instr(
+        prompt="Check State Hub.",
+        trusted_fields=[],
+        model="custodian-triage-balanced",
+        temperature=0.2,
+        max_tokens=1200,
+        max_depth=2,
+        model_params={"reasoning_effort": "medium"},
+    )
+
+    execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert llm.calls == [
+        {
+            "model_name": "custodian-triage-balanced",
+            "temperature": 0.2,
+            "max_tokens": 1200,
+            "max_depth": 2,
+            "model_params": {"reasoning_effort": "medium"},
+        }
+    ]
+
+
+def test_execute_instruction_forwards_output_schema_to_llm_connect(tmp_path, monkeypatch):
+    schema_dir = tmp_path / "schemas"
+    schema_dir.mkdir()
+    schema_path = schema_dir / "daily-triage-report.json"
+    schema = {
+        "type": "object",
+        "required": ["summary", "recommendations"],
+        "properties": {
+            "summary": {"type": "string"},
+            "recommendations": {"type": "array", "items": {"type": "object"}},
+        },
+    }
+    schema_path.write_text(json.dumps(schema), encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+
+    llm = _CountingLLM([
+        json.dumps({"summary": "Review open work.", "recommendations": []})
+    ])
+    instr = _instr(
+        id="daily-triage-report",
+        prompt="Report.",
+        trusted_fields=[],
+        output_schema="schemas/daily-triage-report.json",
+        model_params={"reasoning_effort": "medium"},
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert result.output_validated is True
+    assert llm.calls == [
+        {
+            "model_name": "claude-sonnet-4-6",
+            "model_params": {
+                "reasoning_effort": "medium",
+                "json_schema": schema,
+            },
+        }
+    ]
+
+
+def test_execute_instruction_with_audit_accepts_report_payload():
+    report_data = {
+        "summary": "State Hub has loose ends.",
+        "recommendations": [{"action": "revisit", "candidate": "CUST-WP-0045"}],
+    }
+    llm = _CountingLLM([json.dumps(report_data)])
+    instr = _instr(
+        id="daily-triage-report",
+        prompt="Report.",
+        trusted_fields=[],
+        output_schema="schemas/daily-triage-report.json",
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert result.tasks == []
+    assert result.report == report_data
+    assert result.output_validated is True
+
+
+def test_execute_instruction_with_audit_accepts_fenced_report_payload():
+    report_data = {
+        "summary": "State Hub has loose ends.",
+        "recommendations": [{"action": "revisit", "candidate": "CUST-WP-0045"}],
+    }
+    llm = _CountingLLM([f"```json\n{json.dumps(report_data)}\n```"])
+    instr = _instr(
+        id="daily-triage-report",
+        prompt="Report.",
+        trusted_fields=[],
+        output_schema="schemas/daily-triage-report.json",
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert result.tasks == []
+    assert result.report == report_data
+    assert result.output_validated is True
+    assert llm.call_count == 1
+
+
+def test_execute_instruction_with_audit_rejects_invalid_report_schema():
+    report_data = {"summary": "Missing recommendations."}
+    llm = _CountingLLM([json.dumps(report_data), json.dumps(report_data)])
+    instr = _instr(
+        id="daily-triage-report",
+        prompt="Report.",
+        trusted_fields=[],
+        output_schema="schemas/daily-triage-report.json",
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert result.tasks == []
+    assert result.report is None
+    assert result.output_validated is False
+    assert llm.call_count == 2
+
+
+def test_execute_instruction_with_audit_preserves_invalid_report_with_sinks(
+    tmp_path,
+    monkeypatch,
+):
+    schema_dir = tmp_path / "schemas"
+    schema_dir.mkdir()
+    schema_path = schema_dir / "daily-triage-report.json"
+    schema_path.write_text(
+        json.dumps({
+            "type": "object",
+            "required": ["summary", "recommendations"],
+            "properties": {
+                "summary": {"type": "string"},
+                "recommendations": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": ["action"],
+                    },
+                },
+            },
+        }),
+        encoding="utf-8",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    report_data = {
+        "summary": "Generated partial triage.",
+        "recommendations": [{"rank": 1, "candidate": "CUST-WP-0045"}],
+    }
+    llm = _CountingLLM([json.dumps(report_data), json.dumps(report_data)])
+    instr = _instr(
+        id="daily-triage-report",
+        prompt="Report.",
+        trusted_fields=[],
+        output_schema="schemas/daily-triage-report.json",
+        report_sinks=[{"type": "working-memory", "path": "/tmp"}],
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert result.tasks == []
+    assert result.output_validated is False
+    assert result.review_required is True
+    assert result.validation_error == "$.recommendations[0]: missing required property 'action'"
+    assert result.report is not None
+    assert result.report["status"] == "validation_failed"
+    assert result.report["partial_summary"] == "Generated partial triage."
+    assert result.report["partial_report"] == report_data
+    assert llm.call_count == 2
+
+
+def test_execute_instruction_with_audit_preserves_execution_failure_with_sinks():
+    instr = _instr(
+        id="daily-triage-report",
+        prompt="Report.",
+        trusted_fields=[],
+        report_sinks=[{"type": "working-memory", "path": "/tmp"}],
+    )
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, _FailingLLM())
+
+    assert result.tasks == []
+    assert result.output_validated is False
+    assert result.review_required is True
+    assert result.validation_error == "LLM_CONNECT_URL is not configured"
+    assert result.report == {
+        "summary": (
+            "Instruction daily-triage-report could not run; "
+            "operator review is required."
+        ),
+        "status": "execution_failed",
+        "validation_error": "LLM_CONNECT_URL is not configured",
+    }
+
+
+def test_execute_instruction_with_audit_accepts_report_and_tasks_envelope():
+    envelope = {
+        "report": {"summary": "Review needed."},
+        "tasks": [{"title": "Inspect CUST-WP-0045"}],
+    }
+    llm = _CountingLLM([json.dumps(envelope)])
+    instr = _instr(id="daily-triage-report", prompt="Report.", trusted_fields=[])
+
+    result = execute_instruction_with_audit(instr, _Event(), {}, llm)
+
+    assert result.report == {"summary": "Review needed."}
+    assert len(result.tasks) == 1
+    assert result.tasks[0].title == "Inspect CUST-WP-0045"
+
+
 # ── Condition pre-filter ───────────────────────────────────────────────────────
 
 def test_condition_false_skips_llm():
@@ -235,6 +514,22 @@ def test_review_required_field_on_instruction_def():
     assert defn.review_required is True
 
 
+def test_instruction_def_accepts_llm_connect_depth_config():
+    defn = InstructionDef(
+        id="test",
+        trusted_fields=[],
+        model="custodian-triage-balanced",
+        temperature=0.2,
+        max_tokens=1200,
+        max_depth=2,
+        model_params={"reasoning_effort": "medium"},
+        prompt="p",
+        output_schema="schema.json",
+    )
+    assert defn.max_depth == 2
+    assert defn.model_params == {"reasoning_effort": "medium"}
+
+
 def test_review_required_defaults_to_false():
     defn = InstructionDef(
         id="test",

tests/test_daily_triage_verifier.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+
+def _load_script():
+    path = Path(__file__).parent.parent / "scripts" / "verify_daily_triage.py"
+    spec = importlib.util.spec_from_file_location("verify_daily_triage", path)
+    assert spec is not None
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_daily_triage_verifier_dry_run_names_all_operator_checks() -> None:
+    script = _load_script()
+    args = script.parse_args([
+        "--activity-id",
+        "00000000-0000-0000-0000-000000000123",
+        "--date",
+        "2026-06-04",
+        "--working-memory-dir",
+        "/tmp/wm",
+    ])
+
+    report = script.build_dry_run_report(args)
+
+    assert report["mode"] == "dry-run"
+    names = {check["name"] for check in report["checks"]}
+    assert names == {
+        "temporal_schedule",
+        "latest_workflow_history",
+        "activity_runs_row",
+        "state_hub_progress",
+        "working_memory_note",
+        "llm_timeout_budget",
+    }
+    assert report["activity"]["schedule_id"] == (
+        "activity-schedule-00000000-0000-0000-0000-000000000123"
+    )
+    assert any(
+        check.get("path_glob") == "/tmp/wm/daily-triage-2026-06-04-*.md"
+        for check in report["checks"]
+    )
+    timeout_check = next(
+        check for check in report["checks"] if check["name"] == "llm_timeout_budget"
+    )
+    run_check = next(
+        check for check in report["checks"] if check["name"] == "activity_runs_row"
+    )
+    assert "activity_runs.activity_id" in run_check["sql"]
+    assert "where id = '00000000-0000-0000-0000-000000000123'" in timeout_check["sql"]
+    assert timeout_check["activity_timeout_seconds"] == 900
+    assert timeout_check["retry_attempts"] == 10
+
+
+def test_daily_triage_verifier_default_working_memory_dir() -> None:
+    script = _load_script()
+    args = script.parse_args([])
+
+    assert args.working_memory_dir == "/home/worsch/the-custodian/memory/working"

tests/test_instruction_evaluation.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from activity_core import activities
+
+
+class FakeLLMClient:
+    def __init__(self, response: str) -> None:
+        self.response = response
+        self.calls: list[tuple[str, str, dict | None]] = []
+
+    def complete(
+        self,
+        prompt: str,
+        model: str = "",
+        config: dict | None = None,
+    ) -> str:
+        self.calls.append((prompt, model, config))
+        return self.response
+
+
+@pytest.mark.asyncio
+async def test_evaluate_instructions_returns_task_specs_with_audit(monkeypatch) -> None:
+    llm = FakeLLMClient(json.dumps([
+        {
+            "title": "Run daily triage",
+            "description": "Review State Hub loose ends.",
+            "priority": "high",
+            "labels": ["triage"],
+        }
+    ]))
+    monkeypatch.setattr(activities, "get_llm_client", lambda: llm)
+
+    result = await activities.evaluate_instructions({
+        "instructions": [
+            {
+                "id": "daily-triage",
+                "trusted_fields": ["context.summary.open_tasks"],
+                "model": "test-model",
+                "prompt": "Open tasks: {context.summary.open_tasks}",
+                "output_schema": "",
+                "review_required": False,
+            }
+        ],
+        "event": {},
+        "context": {"summary": {"open_tasks": 3}},
+    })
+
+    task_specs = result["task_specs"]
+    assert len(task_specs) == 1
+    spec = task_specs[0]
+    assert spec["title"] == "Run daily triage"
+    assert spec["source_type"] == "instruction"
+    assert spec["source_id"] == "daily-triage"
+    assert spec["model"] == "test-model"
+    assert spec["output_validated"] is True
+    assert spec["review_required"] is False
+    assert spec["prompt_hash"] is not None
+    assert len(spec["prompt_hash"]) == 64
+    assert result["reports"] == []
+    assert llm.calls == [
+        ("Open tasks: 3", "test-model", {"model_name": "test-model"})
+    ]
+
+
+@pytest.mark.asyncio
+async def test_evaluate_instructions_returns_report_payload(monkeypatch) -> None:
+    llm = FakeLLMClient(json.dumps({
+        "summary": "State Hub has open loose ends.",
+        "recommendations": [{"candidate": "CUST-WP-0045", "action": "work-next"}],
+    }))
+    monkeypatch.setattr(activities, "get_llm_client", lambda: llm)
+
+    result = await activities.evaluate_instructions({
+        "instructions": [
+            {
+                "id": "daily-triage-report",
+                "trusted_fields": [],
+                "model": "test-model",
+                "prompt": "Run report.",
+                "output_schema": "schemas/daily-triage-report.json",
+                "review_required": False,
+            }
+        ],
+        "event": {},
+        "context": {},
+    })
+
+    assert result["task_specs"] == []
+    assert len(result["reports"]) == 1
+    report = result["reports"][0]
+    assert report["instruction_id"] == "daily-triage-report"
+    assert report["report"]["summary"] == "State Hub has open loose ends."
+    assert report["output_validated"] is True
+    assert report["prompt_hash"] is not None
+
+
+@pytest.mark.asyncio
+async def test_evaluate_instructions_returns_invalid_report_for_report_sinks(
+    monkeypatch,
+    tmp_path,
+) -> None:
+    schema_dir = tmp_path / "schemas"
+    schema_dir.mkdir()
+    (schema_dir / "daily-triage-report.json").write_text(
+        json.dumps({
+            "type": "object",
+            "required": ["summary", "recommendations"],
+            "properties": {
+                "summary": {"type": "string"},
+                "recommendations": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "required": ["wsjf"],
+                    },
+                },
+            },
+        }),
+        encoding="utf-8",
+    )
+    monkeypatch.chdir(tmp_path)
+    llm = FakeLLMClient(json.dumps({
+        "summary": "Partial triage.",
+        "recommendations": [{"rank": 1, "candidate": "CUST-WP-0045"}],
+    }))
+    monkeypatch.setattr(activities, "get_llm_client", lambda: llm)
+
+    result = await activities.evaluate_instructions({
+        "instructions": [
+            {
+                "id": "daily-triage-report",
+                "trusted_fields": [],
+                "model": "test-model",
+                "prompt": "Run report.",
+                "output_schema": "schemas/daily-triage-report.json",
+                "review_required": False,
+                "report_sinks": [{"type": "working-memory", "path": "/tmp"}],
+            }
+        ],
+        "event": {},
+        "context": {},
+    })
+
+    assert result["task_specs"] == []
+    assert len(result["reports"]) == 1
+    report = result["reports"][0]
+    assert report["output_validated"] is False
+    assert report["review_required"] is True
+    assert report["validation_error"] == "$.recommendations[0]: missing required property 'wsjf'"
+    assert report["report"]["status"] == "validation_failed"
+    assert report["report"]["partial_summary"] == "Partial triage."
+
+
+@pytest.mark.asyncio
+async def test_evaluate_instructions_without_llm_client_returns_no_tasks(monkeypatch) -> None:
+    class RaisingClient:
+        def complete(
+            self,
+            prompt: str,
+            model: str = "",
+            config: dict | None = None,
+        ) -> str:  # noqa: ARG002
+            raise RuntimeError("not configured")
+
+    monkeypatch.setattr(activities, "get_llm_client", lambda: RaisingClient())
+
+    result = await activities.evaluate_instructions({
+        "instructions": [
+            {
+                "id": "daily-triage",
+                "trusted_fields": [],
+                "model": "test-model",
+                "prompt": "Run triage.",
+                "output_schema": "schemas/daily-triage-report.json",
+            }
+        ],
+        "event": {},
+        "context": {},
+    })
+
+    assert result == {"task_specs": [], "reports": []}
+
+
+@pytest.mark.asyncio
+async def test_evaluate_instructions_forwards_llm_connect_depth_config(monkeypatch) -> None:
+    llm = FakeLLMClient(json.dumps({"summary": "ok", "recommendations": []}))
+    monkeypatch.setattr(activities, "get_llm_client", lambda: llm)
+
+    await activities.evaluate_instructions({
+        "instructions": [
+            {
+                "id": "daily-triage-report",
+                "trusted_fields": [],
+                "model": "custodian-triage-balanced",
+                "temperature": 0.2,
+                "max_tokens": 1200,
+                "max_depth": 2,
+                "model_params": {"reasoning_effort": "medium"},
+                "prompt": "Run report.",
+                "output_schema": "schemas/daily-triage-report.json",
+                "review_required": False,
+            }
+        ],
+        "event": {},
+        "context": {},
+    })
+
+    assert llm.calls[0][2] == {
+        "model_name": "custodian-triage-balanced",
+        "temperature": 0.2,
+        "max_tokens": 1200,
+        "max_depth": 2,
+        "model_params": {
+            "reasoning_effort": "medium",
+            "json_schema": {
+                "type": "object",
+                "required": ["summary", "recommendations"],
+                "properties": {
+                    "summary": {"type": "string"},
+                    "recommendations": {
+                        "type": "array",
+                        "items": {"type": "object"},
+                    },
+                },
+            },
+        },
+    }

tests/test_integration_event_bridge.py

@@ -20,11 +20,12 @@ import pytest
 from activity_core.definition_parser import parse_file
 from activity_core.issue_sink import NullSink
 from activity_core.models import EventEnvelope
-from activity_core.rules.evaluator import evaluate_condition
+from activity_core.rules.actions import expand_rule_actions
 from activity_core.rules.models import TaskRef, TaskSpec
 
 _DEFINITIONS_DIR = Path(__file__).parent.parent / "activity-definitions"
 _SBOM_DEF_PATH = _DEFINITIONS_DIR / "weekly-sbom-staleness.md"
+_CODING_RETRO_DEF_PATH = _DEFINITIONS_DIR / "weekly-coding-retro.md"
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
@@ -59,27 +60,24 @@ def _run_rule_pipeline(
     spawn_log: list[dict] = []
     triggering_event_id = str(uuid.uuid4())
 
-    for repo in repos:
+    context = {"repos": {"repos": repos}}
-        context = {"repos": repo}
+    for spec_dict in expand_rule_actions([rule], event, context):
-        if not evaluate_condition(rule["condition"], event, context):
-            continue
-
-        action = rule.get("action", {})
         spec = TaskSpec(
-            title=f"Run SBOM rescan — {repo['repo_slug']}",
+            title=spec_dict["title"],
-            description="SBOM rescan needed — age threshold exceeded.",
+            description=spec_dict["description"],
-            target_repo=repo["repo_slug"],
+            target_repo=spec_dict["target_repo"],
-            priority=action.get("priority", "medium"),
+            priority=spec_dict["priority"],
-            labels=action.get("labels", []),
+            labels=spec_dict["labels"],
+            due_in_days=spec_dict["due_in_days"],
             source_type="rule",
-            source_id=rule["id"],
+            source_id=spec_dict["source_id"],
             triggering_event_id=triggering_event_id,
         )
         ref = sink.emit(spec)
         task_refs.append(ref)
         spawn_log.append({
-            "source_id": rule["id"],
+            "source_id": spec_dict["source_id"],
-            "condition_matched": rule["condition"],
+            "condition_matched": spec_dict["condition"],
             "triggering_event_id": triggering_event_id,
             "task_ref": ref.external_id,
         })
@@ -98,6 +96,69 @@ def test_sbom_definition_parses_correctly():
     assert defn.rules[0]["id"] == "flag-stale-sbom"
 
 
+def test_coding_retro_definition_parses_disabled_until_verified():
+    defn = parse_file(_CODING_RETRO_DEF_PATH)
+
+    assert defn.id == "weekly-coding-retro"
+    assert defn.enabled is False
+    assert defn.trigger_config["trigger_type"] == "cron"
+    assert defn.trigger_config["cron_expression"] == "0 19 * * 6"
+    assert defn.trigger_config["timezone"] == "Europe/Berlin"
+    assert defn.context_sources == [
+        {
+            "type": "state-hub",
+            "query": "coding_retro",
+            "params": {"window_days": 7, "limit": 100},
+            "bind_to": "context.retro",
+        }
+    ]
+    assert len(defn.rules) == 1
+    assert defn.rules[0]["id"] == "propose-weekly-improvements"
+
+
+def test_coding_retro_rule_emits_one_task_per_positive_suggestion():
+    defn = parse_file(_CODING_RETRO_DEF_PATH)
+    rule = defn.rules[0]
+    context = {
+        "retro": {
+            "suggestions": [
+                {
+                    "repo": "activity-core",
+                    "title": "Harden coding retro smoke gates",
+                    "recommendation": "Dry-run with fixture and live hub evidence.",
+                    "priority": "high",
+                    "score": 8.5,
+                },
+                {
+                    "repo": "quiet-repo",
+                    "title": "Do not emit zero-score suggestion",
+                    "recommendation": "This should stay quiet.",
+                    "priority": "low",
+                    "score": 0,
+                },
+            ]
+        }
+    }
+
+    specs = expand_rule_actions([rule], _EmptyEvent(), context)
+
+    assert specs == [
+        {
+            "title": "Harden coding retro smoke gates",
+            "description": "Dry-run with fixture and live hub evidence.",
+            "target_repo": "activity-core",
+            "priority": "high",
+            "labels": ["coding-retro", "improvement", "automated"],
+            "due_in_days": None,
+            "source_type": "rule",
+            "source_id": "propose-weekly-improvements",
+            "triggering_event_id": "",
+            "activity_definition_id": "",
+            "condition": "context.s.score > 0",
+        }
+    ]
+
+
 def test_pipeline_emits_one_task_for_stale_repo_only():
     """Stale repo (45 days) matches; fresh repo (10 days) does not."""
     defn = parse_file(_SBOM_DEF_PATH)
@@ -121,7 +182,7 @@ def test_pipeline_emits_one_task_for_stale_repo_only():
     assert len(spawn_log) == 1
     entry = spawn_log[0]
     assert entry["source_id"] == "flag-stale-sbom"
-    assert entry["condition_matched"] == "context.repos.sbom_age_days > 30"
+    assert entry["condition_matched"] == "context.repo.sbom_age_days > 30"
     assert entry["triggering_event_id"] == spawn_log[0]["triggering_event_id"]
 
 

tests/test_issue_sink.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import pytest
+
+from activity_core import activities
+from activity_core.issue_sink import IssueCoreRestSink
+from activity_core.rules.models import TaskRef, TaskSpec
+
+
+class DummyResponse:
+    def __init__(self, payload: dict[str, Any]) -> None:
+        self.payload = payload
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self) -> dict[str, Any]:
+        return self.payload
+
+
+def test_issue_core_rest_sink_posts_task_contract(monkeypatch) -> None:
+    posts: list[dict[str, Any]] = []
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        posts.append({"url": url, **kwargs})
+        return DummyResponse({
+            "issue_id": "issue-123",
+            "issue_url": "http://issue-core.test/issues/issue-123",
+            "backend": "issue-core",
+        })
+
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    ref = IssueCoreRestSink("http://issue-core.test/").emit(TaskSpec(
+        title="Run SBOM rescan for activity-core",
+        description="SBOM is older than 30 days.",
+        target_repo="activity-core",
+        priority="medium",
+        labels=["sbom", "security", "automated"],
+        due_in_days=7,
+        source_type="rule",
+        source_id="flag-stale-sbom",
+        triggering_event_id="scheduled",
+        activity_definition_id="activity-1",
+    ))
+
+    assert ref == TaskRef(
+        external_id="issue-123",
+        backend_url="http://issue-core.test/issues/issue-123",
+        backend="issue-core",
+    )
+    assert posts == [
+        {
+            "url": "http://issue-core.test/issues/",
+            "json": {
+                "title": "Run SBOM rescan for activity-core",
+                "description": "SBOM is older than 30 days.",
+                "target_repo": "activity-core",
+                "priority": "medium",
+                "labels": ["sbom", "security", "automated"],
+                "due_in_days": 7,
+                "source_type": "rule",
+                "source_id": "flag-stale-sbom",
+                "triggering_event_id": "scheduled",
+                "activity_definition_id": "activity-1",
+            },
+            "timeout": 10.0,
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_emit_tasks_raises_when_sink_fails(monkeypatch) -> None:
+    class FailingSink:
+        def emit(self, task_spec: TaskSpec) -> TaskRef:
+            raise RuntimeError(f"boom for {task_spec.title}")
+
+    class FakeTransaction:
+        async def __aenter__(self) -> None:
+            return None
+
+        async def __aexit__(self, *exc_info: object) -> bool:
+            return False
+
+    class FakeSession:
+        def begin(self) -> FakeTransaction:
+            return FakeTransaction()
+
+        async def __aenter__(self) -> "FakeSession":
+            return self
+
+        async def __aexit__(self, *exc_info: object) -> bool:
+            return False
+
+        def add(self, row: object) -> None:
+            raise AssertionError("failed emissions should not write spawn logs")
+
+    class FakeSessionFactory:
+        def __call__(self) -> FakeSession:
+            return FakeSession()
+
+    monkeypatch.setattr(activities, "get_issue_sink", lambda: FailingSink())
+    monkeypatch.setattr(activities, "_get_session_factory", lambda: FakeSessionFactory())
+
+    with pytest.raises(RuntimeError, match="task emission sink failure"):
+        await activities.emit_tasks({
+            "activity_id": "00000000-0000-0000-0000-000000000001",
+            "triggering_event_id": "scheduled",
+            "run_id": "00000000-0000-0000-0000-000000000002",
+            "task_specs": [
+                {
+                    "title": "Run SBOM rescan for activity-core",
+                    "description": "",
+                    "target_repo": "activity-core",
+                    "priority": "medium",
+                    "labels": ["sbom"],
+                    "due_in_days": None,
+                    "source_type": "rule",
+                    "source_id": "flag-stale-sbom",
+                    "condition": "context.repo.sbom_age_days > 30",
+                }
+            ],
+        })

tests/test_llm_client.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import httpx
+
+from activity_core.llm_client import LLMConnectClient
+
+
+def test_llm_connect_client_forwards_run_config(monkeypatch) -> None:
+    captured: dict = {}
+
+    class Response:
+        def raise_for_status(self) -> None:
+            pass
+
+        def json(self) -> dict:
+            return {"content": '{"summary":"ok","recommendations":[]}'}
+
+    def fake_post(url: str, json: dict, timeout: float) -> Response:
+        captured["url"] = url
+        captured["json"] = json
+        captured["timeout"] = timeout
+        return Response()
+
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    client = LLMConnectClient("http://llm-connect.local/", timeout_seconds=42)
+    result = client.complete(
+        "Prompt",
+        model="fallback-model",
+        config={
+            "model_name": "custodian-triage-balanced",
+            "temperature": 0.2,
+            "max_tokens": 1200,
+            "max_depth": 2,
+            "model_params": {"reasoning_effort": "medium"},
+        },
+    )
+
+    assert result == '{"summary":"ok","recommendations":[]}'
+    assert captured["url"] == "http://llm-connect.local/execute"
+    assert captured["timeout"] == 42
+    assert captured["json"] == {
+        "prompt": "Prompt",
+        "config": {
+            "model_name": "custodian-triage-balanced",
+            "temperature": 0.2,
+            "max_tokens": 1200,
+            "max_depth": 2,
+            "model_params": {"reasoning_effort": "medium"},
+            "timeout_seconds": 42,
+        },
+    }

tests/test_ops_event_types.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from activity_core.event_type_registry import parse_event_type_file
+
+_EVENT_DIR = Path(__file__).parent.parent / "event-types"
+_OPS_EVENT_TYPES = {
+    "ops-service-observed",
+    "ops-endpoint-verified",
+    "ops-access-path-checked",
+    "ops-backup-verified",
+    "ops-inventory-drift",
+}
+
+
+def test_ops_event_type_definitions_parse_and_expose_required_fields() -> None:
+    for type_id in _OPS_EVENT_TYPES:
+        path = _EVENT_DIR / f"{type_id}.md"
+        event_type = parse_event_type_file(path)
+
+        assert event_type.type_id == type_id
+        assert event_type.publisher == "activity-core"
+        assert event_type.status == "active"
+        assert event_type.attribute_schema["activity_core_run_id"]["required"] is True
+        assert event_type.attribute_schema["idempotency_key"]["required"] is True
+        assert event_type.attribute_schema["service_id"]["required"] is True
+        assert event_type.attribute_schema["observed_status"]["required"] is True
+        assert "raw response" in event_type.raw_md
+        assert "unredacted URL query strings" in event_type.raw_md
+
+
+def test_endpoint_event_contract_captures_probe_result_fields() -> None:
+    event_type = parse_event_type_file(_EVENT_DIR / "ops-endpoint-verified.md")
+
+    for field in (
+        "endpoint_id",
+        "endpoint_url",
+        "expected_status",
+        "status_code",
+        "matched_expected_status",
+        "matched_expected_signal",
+    ):
+        assert field in event_type.attribute_schema

tests/test_ops_evidence_sinks.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+from activity_core.ops_evidence_sinks import persist_ops_inventory_evidence
+
+
+class DummyResponse:
+    def __init__(self, payload: Any) -> None:
+        self.payload = payload
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self) -> Any:
+        return self.payload
+
+
+def _payload(sinks: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "activity_id": "activity-1",
+        "run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+        "scheduled_for": "2026-06-05T10:15:00+00:00",
+        "version_used": 1,
+        "context_sources": [
+            {
+                "type": "ops-inventory",
+                "query": "probe_services",
+                "bind_to": "context.ops_probe",
+                "params": {"evidence_sinks": sinks},
+            }
+        ],
+        "context": {
+            "ops_probe": {
+                "generated_at": "2026-06-05T10:15:01+00:00",
+                "inventory_path": "/tmp/service-inventory.yml",
+                "summary": {"ok": 1, "degraded": 0, "down": 0, "skipped": 1},
+                "services": [
+                    {
+                        "service_id": "state-hub",
+                        "name": "State Hub",
+                        "kind": "coordination-service",
+                        "environment": "local",
+                        "lifecycle_state": "observed",
+                        "declared_health_status": "unknown",
+                        "owner_repos": ["state-hub"],
+                        "endpoint_count": 1,
+                        "access_path_count": 1,
+                    }
+                ],
+                "endpoints": [
+                    {
+                        "service_id": "state-hub",
+                        "service_name": "State Hub",
+                        "endpoint_id": "state-hub-health",
+                        "endpoint_type": "http",
+                        "url": "http://user:pass@state-hub.test/health?token=secret",
+                        "expected_status": 200,
+                        "expected_signal_present": True,
+                        "widget_ref": "ops:endpoint:state-hub-health",
+                        "status": "ok",
+                        "status_code": 200,
+                        "matched_expected_status": True,
+                        "matched_expected_signal": True,
+                        "response_body": "secret response body",
+                        "headers": {"Authorization": "Bearer secret"},
+                    }
+                ],
+                "access_paths": [
+                    {
+                        "service_id": "state-hub",
+                        "service_name": "State Hub",
+                        "access_path_id": "state-hub-access-1",
+                        "access_path_type": "k8s",
+                        "declared_status": "unknown",
+                        "status": "skipped",
+                        "reason": "unsupported_access_path_type",
+                    }
+                ],
+            }
+        },
+    }
+
+
+def test_state_hub_progress_sink_posts_compact_probe_summary(monkeypatch) -> None:
+    posts: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        assert url == "http://state-hub.test/progress/"
+        return DummyResponse([])
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        posts.append({"url": url, **kwargs})
+        return DummyResponse({"id": "progress-1"})
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    result = persist_ops_inventory_evidence(
+        _payload([
+            {
+                "type": "state-hub-progress",
+                "state_hub_url": "http://state-hub.test",
+                "event_type": "ops_inventory_probe",
+                "workstream_id": "workstream-1",
+                "task_id": "task-1",
+            }
+        ])
+    )
+
+    assert result == [
+        {
+            "type": "state-hub-progress",
+            "status": "posted",
+            "event_type": "ops_inventory_probe",
+            "progress_id": "progress-1",
+            "idempotency_key": "12345678-aaaa-bbbb-cccc-123456789abc:ops_probe:ops_inventory_probe",
+            "context_key": "ops_probe",
+        }
+    ]
+    body = posts[0]["json"]
+    assert body["summary"] == "Ops inventory probe: 1 ok, 0 degraded, 0 down, 1 skipped"
+    assert body["workstream_id"] == "workstream-1"
+    assert body["task_id"] == "task-1"
+    assert body["detail"]["activity_core_run_id"] == _run_id()
+    assert body["detail"]["idempotency_key"] == result[0]["idempotency_key"]
+    assert body["detail"]["probe"]["endpoints"][0]["url"] == "http://state-hub.test/health"
+
+    serialized = json.dumps(body, sort_keys=True)
+    assert "secret response body" not in serialized
+    assert "Authorization" not in serialized
+    assert "user:pass" not in serialized
+    assert "token=secret" not in serialized
+
+
+def test_state_hub_progress_sink_is_idempotent(monkeypatch) -> None:
+    idempotency_key = f"{_run_id()}:ops_probe:ops_inventory_probe"
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse([
+            {
+                "event_type": "ops_inventory_probe",
+                "detail": {"idempotency_key": idempotency_key},
+            }
+        ])
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        raise AssertionError("post should not be called")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    result = persist_ops_inventory_evidence(
+        _payload([
+            {
+                "type": "state-hub-progress",
+                "state_hub_url": "http://state-hub.test",
+            }
+        ])
+    )
+
+    assert result[0]["status"] == "exists"
+    assert result[0]["idempotency_key"] == idempotency_key
+
+
+def test_inter_hub_sink_skips_cleanly_when_config_missing(monkeypatch) -> None:
+    monkeypatch.delenv("INTER_HUB_URL", raising=False)
+    monkeypatch.delenv("OPS_HUB_KEY", raising=False)
+
+    result = persist_ops_inventory_evidence(
+        _payload([{"type": "inter-hub-interaction-event"}])
+    )
+
+    assert result == [
+        {
+            "type": "inter-hub-interaction-event",
+            "status": "skipped",
+            "reason": "missing_inter_hub_config",
+            "missing": ["INTER_HUB_URL", "OPS_HUB_KEY", "widget_mapping"],
+        }
+    ]
+
+
+def test_inter_hub_sink_accepts_widget_mapping_from_env(monkeypatch) -> None:
+    monkeypatch.delenv("INTER_HUB_URL", raising=False)
+    monkeypatch.delenv("OPS_HUB_KEY", raising=False)
+    monkeypatch.setenv("OPS_HUB_WIDGET_MAPPING", "ops:endpoint:gitea-registry")
+
+    result = persist_ops_inventory_evidence(
+        _payload([{"type": "inter-hub-interaction-event"}])
+    )
+
+    assert result == [
+        {
+            "type": "inter-hub-interaction-event",
+            "status": "skipped",
+            "reason": "missing_inter_hub_config",
+            "missing": ["INTER_HUB_URL", "OPS_HUB_KEY"],
+        }
+    ]
+
+
+def test_no_evidence_sinks_returns_no_results() -> None:
+    payload = _payload([])
+    payload["context_sources"][0]["params"] = {}
+
+    assert persist_ops_inventory_evidence(payload) == []
+
+
+def _run_id() -> str:
+    return "12345678-aaaa-bbbb-cccc-123456789abc"

tests/test_ops_inventory_context_resolver.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import httpx
+import pytest
+
+from activity_core.context_resolvers.ops_inventory import OpsInventoryContextResolver
+
+
+class DummyResponse:
+    def __init__(self, status_code: int, text: str = "") -> None:
+        self.status_code = status_code
+        self.text = text
+
+
+def _write_inventory(tmp_path: Path, services: str) -> Path:
+    path = tmp_path / "service-inventory.yml"
+    path.write_text(
+        f"""
+version: 1
+last_reviewed: "2026-06-05"
+environments: []
+hosts: []
+clusters: []
+services:
+{services}
+""",
+        encoding="utf-8",
+    )
+    return path
+
+
+def test_probe_services_reports_ok_endpoint_and_skipped_access_path(
+    tmp_path,
+    monkeypatch,
+) -> None:
+    inventory = _write_inventory(
+        tmp_path,
+        """
+  - id: state-hub
+    name: State Hub
+    kind: coordination-service
+    lifecycle_state: observed
+    health_status: unknown
+    environment: local
+    owner_repos: [state-hub]
+    endpoints:
+      - id: state-hub-health
+        type: http
+        url: "http://127.0.0.1:8000/state/health"
+        expected_status: 200
+        expected_signal: "health response"
+    access_paths:
+      - type: k8s
+        target: local
+        status: unknown
+""",
+    )
+    calls: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        return DummyResponse(200, "ok: health response")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = OpsInventoryContextResolver().resolve(
+        "probe_services",
+        None,
+        {"inventory_path": str(inventory)},
+    )
+
+    assert result["summary"] == {"ok": 1, "degraded": 0, "down": 0, "skipped": 1}
+    assert result["services"][0]["service_id"] == "state-hub"
+    assert result["endpoints"][0]["status"] == "ok"
+    assert result["endpoints"][0]["matched_expected_status"] is True
+    assert result["endpoints"][0]["matched_expected_signal"] is True
+    assert result["access_paths"][0]["status"] == "skipped"
+    assert result["access_paths"][0]["reason"] == "unsupported_access_path_type"
+    assert calls == [
+        {
+            "url": "http://127.0.0.1:8000/state/health",
+            "timeout": 10.0,
+            "follow_redirects": False,
+        }
+    ]
+
+
+def test_probe_services_marks_status_mismatch_degraded(tmp_path, monkeypatch) -> None:
+    inventory = _write_inventory(
+        tmp_path,
+        """
+  - id: gitea
+    name: Gitea
+    kind: application
+    lifecycle_state: observed
+    health_status: unknown
+    environment: coulombcore
+    owner_repos: [railiance-apps]
+    endpoints:
+      - id: gitea-registry
+        type: https
+        url: "https://gitea.coulomb.social/v2/"
+        expected_status: 401
+        expected_signal: "OCI registry auth challenge"
+    access_paths: []
+""",
+    )
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse(200, "OCI registry auth challenge")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = OpsInventoryContextResolver().resolve(
+        "probe_services",
+        None,
+        {"inventory_path": str(inventory)},
+    )
+
+    endpoint = result["endpoints"][0]
+    assert result["summary"] == {"ok": 0, "degraded": 1, "down": 0, "skipped": 0}
+    assert endpoint["status"] == "degraded"
+    assert endpoint["reason"] == "expected_status_mismatch"
+    assert endpoint["matched_expected_status"] is False
+    assert endpoint["matched_expected_signal"] is True
+
+
+def test_probe_services_marks_signal_mismatch_degraded(tmp_path, monkeypatch) -> None:
+    inventory = _write_inventory(
+        tmp_path,
+        """
+  - id: inter-hub
+    name: Inter-Hub
+    kind: governance-service
+    lifecycle_state: observed
+    health_status: unknown
+    environment: threephoenix-prod
+    owner_repos: [inter-hub]
+    endpoints:
+      - id: inter-hub-openapi
+        type: https
+        url: "https://hub.coulomb.social/api/v2/openapi.json"
+        expected_status: 200
+        expected_signal: "OpenAPI document"
+    access_paths: []
+""",
+    )
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse(200, "{}")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = OpsInventoryContextResolver().resolve(
+        "probe_services",
+        None,
+        {"inventory_path": str(inventory)},
+    )
+
+    endpoint = result["endpoints"][0]
+    assert result["summary"] == {"ok": 0, "degraded": 1, "down": 0, "skipped": 0}
+    assert endpoint["status"] == "degraded"
+    assert endpoint["reason"] == "expected_signal_missing"
+    assert endpoint["matched_expected_status"] is True
+    assert endpoint["matched_expected_signal"] is False
+
+
+def test_probe_services_marks_network_error_down_and_sanitizes_output(
+    tmp_path,
+    monkeypatch,
+) -> None:
+    inventory = _write_inventory(
+        tmp_path,
+        """
+  - id: private-api
+    name: Private API
+    kind: application
+    lifecycle_state: observed
+    health_status: unknown
+    environment: local
+    owner_repos: [secret-repo]
+    endpoints:
+      - id: private-api-health
+        type: https
+        url: "https://user:pass@example.test/health?token=super-secret"
+        expected_status: 200
+        expected_signal: "secret response body"
+    access_paths: []
+""",
+    )
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        raise httpx.ConnectError("offline")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = OpsInventoryContextResolver().resolve(
+        "probe_services",
+        None,
+        {"inventory_path": str(inventory)},
+    )
+    serialized = json.dumps(result, sort_keys=True)
+
+    endpoint = result["endpoints"][0]
+    assert result["summary"] == {"ok": 0, "degraded": 0, "down": 1, "skipped": 0}
+    assert endpoint["status"] == "down"
+    assert endpoint["url"] == "https://example.test/health"
+    assert "super-secret" not in serialized
+    assert "user:pass" not in serialized
+    assert "secret response body" not in serialized
+
+
+def test_probe_services_skips_unsupported_and_network_disabled(
+    tmp_path,
+    monkeypatch,
+) -> None:
+    inventory = _write_inventory(
+        tmp_path,
+        """
+  - id: bridge
+    name: Ops Bridge
+    kind: bridge
+    lifecycle_state: observed
+    health_status: unknown
+    environment: local
+    owner_repos: [ops-bridge]
+    endpoints:
+      - id: bridge-ssh
+        type: ssh
+        url: "ssh://bridge.example"
+      - id: bridge-http
+        type: http
+        url: "http://bridge.example/health"
+    access_paths: []
+""",
+    )
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        raise AssertionError("network should be disabled")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = OpsInventoryContextResolver().resolve(
+        "probe_services",
+        None,
+        {"inventory_path": str(inventory), "allow_network": False},
+    )
+
+    assert result["summary"] == {"ok": 0, "degraded": 0, "down": 0, "skipped": 2}
+    assert [entry["reason"] for entry in result["endpoints"]] == [
+        "kind_not_included",
+        "network_disabled",
+    ]
+
+
+def test_probe_services_missing_inventory_optional_and_required(tmp_path) -> None:
+    missing = tmp_path / "missing.yml"
+    resolver = OpsInventoryContextResolver()
+
+    optional = resolver.resolve(
+        "probe_services",
+        None,
+        {"inventory_path": str(missing), "required": False},
+    )
+
+    assert optional["status"] == "skipped"
+    assert optional["reason"] == "inventory_not_found"
+    assert optional["summary"] == {"ok": 0, "degraded": 0, "down": 0, "skipped": 1}
+
+    with pytest.raises(FileNotFoundError):
+        resolver.resolve(
+            "probe_services",
+            None,
+            {"inventory_path": str(missing), "required": True},
+        )
+
+
+def test_unknown_query_returns_empty() -> None:
+    assert OpsInventoryContextResolver().resolve("unknown", None, {}) == {}

tests/test_railiance_ops_inventory_wiring.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+import httpx
+
+from activity_core.definition_parser import parse_file
+from activity_core.context_resolvers.ops_inventory import OpsInventoryContextResolver
+from activity_core.ops_evidence_sinks import persist_ops_inventory_evidence
+
+_REPO_ROOT = Path(__file__).parent.parent
+_RUNTIME_PATH = _REPO_ROOT / "k8s" / "railiance" / "20-runtime.yaml"
+_BOOTSTRAP_SECRETS_PATH = _REPO_ROOT / "k8s" / "railiance" / "bootstrap-secrets.sh"
+
+
+def _resources() -> list[dict[str, Any]]:
+    return [
+        resource
+        for resource in yaml.safe_load_all(_RUNTIME_PATH.read_text(encoding="utf-8"))
+        if isinstance(resource, dict)
+    ]
+
+
+def _by_kind_name(kind: str, name: str) -> dict[str, Any]:
+    for resource in _resources():
+        if resource.get("kind") == kind and resource.get("metadata", {}).get("name") == name:
+            return resource
+    raise AssertionError(f"missing {kind}/{name}")
+
+
+def test_runtime_config_has_ops_inventory_placeholders() -> None:
+    config = _by_kind_name("ConfigMap", "actcore-runtime-config")
+
+    assert config["data"]["LLM_CONNECT_URL"] == ""
+    assert config["data"]["LLM_CONNECT_TIMEOUT_SECONDS"] == "300"
+    assert config["data"]["OPS_INVENTORY_PATH"] == (
+        "/etc/activity-core/ops/service-inventory.yml"
+    )
+    assert config["data"]["INTER_HUB_URL"] == ""
+    assert config["data"]["OPS_HUB_WIDGET_MAPPING"] == ""
+
+
+def test_external_configmap_projects_disabled_ops_probe_definition(tmp_path) -> None:
+    config = _by_kind_name("ConfigMap", "actcore-external-activity-definitions")
+    raw_definition = config["data"]["ops-service-inventory-probes.md"]
+    definition_path = tmp_path / "ops-service-inventory-probes.md"
+    definition_path.write_text(raw_definition, encoding="utf-8")
+
+    definition = parse_file(definition_path)
+
+    assert definition.name == "Ops Service Inventory Probes"
+    assert definition.enabled is False
+    assert definition.trigger_config["cron_expression"] == "15 * * * *"
+    assert definition.context_sources == [
+        {
+            "type": "ops-inventory",
+            "query": "probe_services",
+            "required": False,
+            "params": {
+                "inventory_path": "/etc/activity-core/ops/service-inventory.yml",
+                "timeout_seconds": 10,
+                "include_kinds": ["http", "https"],
+                "allow_network": True,
+                "evidence_sinks": [
+                    {
+                        "type": "state-hub-progress",
+                        "event_type": "ops_inventory_probe",
+                        "author": "activity-core",
+                    }
+                ],
+            },
+            "bind_to": "context.ops_inventory_probe",
+        }
+    ]
+
+
+def test_external_configmap_projects_enabled_daily_wsjf_definition(tmp_path) -> None:
+    config = _by_kind_name("ConfigMap", "actcore-external-activity-definitions")
+    raw_definition = config["data"]["daily-statehub-wsjf-triage.md"]
+    definition_path = tmp_path / "daily-statehub-wsjf-triage.md"
+    definition_path.write_text(raw_definition, encoding="utf-8")
+
+    definition = parse_file(definition_path)
+    instruction = definition.instructions[0]
+
+    assert definition.id == "6fca51fa-387a-4fd0-bc4e-d62c29eb859a"
+    assert definition.name == "Daily State Hub WSJF Triage"
+    assert definition.enabled is True
+    assert definition.trigger_config["cron_expression"] == "20 7 * * *"
+    assert definition.trigger_config["timezone"] == "Europe/Berlin"
+    assert instruction["id"] == "daily-triage-report"
+    assert instruction["output_schema"] == (
+        "/etc/activity-core/schemas/daily-triage-report.json"
+    )
+    assert instruction["report_sinks"][0]["type"] == "working-memory"
+    assert instruction["report_sinks"][1]["event_type"] == "daily_triage"
+
+
+def test_ops_inventory_configmap_contains_probeable_inventory() -> None:
+    config = _by_kind_name("ConfigMap", "actcore-ops-service-inventory")
+    inventory = yaml.safe_load(config["data"]["service-inventory.yml"])
+
+    services = {service["id"]: service for service in inventory["services"]}
+
+    assert inventory["policy"]["non_secret_inventory"] is True
+    assert services["gitea"]["endpoints"][0]["id"] == "gitea-oci-registry"
+    assert services["state-hub"]["endpoints"][0]["url"] == (
+        "http://actcore-state-hub-bridge:8000/state/health"
+    )
+    assert services["inter-hub"]["endpoints"][0]["id"] == "inter-hub-openapi"
+    assert services["activity-core"]["endpoints"][0]["id"] == "activity-core-api"
+
+
+def test_worker_mounts_ops_inventory_configmap() -> None:
+    deployment = _by_kind_name("Deployment", "actcore-worker")
+    pod_spec = deployment["spec"]["template"]["spec"]
+    container = pod_spec["containers"][0]
+
+    mounts = {mount["name"]: mount for mount in container["volumeMounts"]}
+    volumes = {volume["name"]: volume for volume in pod_spec["volumes"]}
+
+    assert mounts["ops-service-inventory"]["mountPath"] == "/etc/activity-core/ops"
+    assert mounts["ops-service-inventory"]["readOnly"] is True
+    assert volumes["ops-service-inventory"]["configMap"]["name"] == (
+        "actcore-ops-service-inventory"
+    )
+
+
+def test_worker_mounts_daily_triage_schema_and_working_memory() -> None:
+    deployment = _by_kind_name("Deployment", "actcore-worker")
+    pod_spec = deployment["spec"]["template"]["spec"]
+    container = pod_spec["containers"][0]
+
+    mounts = {mount["name"]: mount for mount in container["volumeMounts"]}
+    volumes = {volume["name"]: volume for volume in pod_spec["volumes"]}
+    schema_config = _by_kind_name("ConfigMap", "actcore-report-schemas")
+
+    assert "daily-triage-report.json" in schema_config["data"]
+    assert mounts["report-schemas"]["mountPath"] == "/etc/activity-core/schemas"
+    assert mounts["report-schemas"]["readOnly"] is True
+    assert volumes["report-schemas"]["configMap"]["name"] == "actcore-report-schemas"
+    assert mounts["working-memory"]["mountPath"] == (
+        "/home/worsch/the-custodian/memory/working"
+    )
+    assert volumes["working-memory"]["persistentVolumeClaim"]["claimName"] == (
+        "actcore-working-memory"
+    )
+
+
+def test_ops_hub_key_is_secret_only_placeholder() -> None:
+    runtime_config = _by_kind_name("ConfigMap", "actcore-runtime-config")
+    bootstrap = _BOOTSTRAP_SECRETS_PATH.read_text(encoding="utf-8")
+
+    assert "OPS_HUB_KEY" not in runtime_config["data"]
+    assert '--from-literal=OPS_HUB_KEY=""' in bootstrap
+
+
+def test_disabled_ops_probe_definition_can_emit_fixture_evidence(
+    tmp_path,
+    monkeypatch,
+) -> None:
+    definition_config = _by_kind_name("ConfigMap", "actcore-external-activity-definitions")
+    inventory_config = _by_kind_name("ConfigMap", "actcore-ops-service-inventory")
+    definition_path = tmp_path / "ops-service-inventory-probes.md"
+    inventory_path = tmp_path / "service-inventory.yml"
+    definition_path.write_text(
+        definition_config["data"]["ops-service-inventory-probes.md"],
+        encoding="utf-8",
+    )
+    inventory_path.write_text(
+        inventory_config["data"]["service-inventory.yml"],
+        encoding="utf-8",
+    )
+    definition = parse_file(definition_path)
+    source = definition.context_sources[0]
+    source["params"]["inventory_path"] = str(inventory_path)
+
+    def fake_endpoint_get(url: str, **kwargs: Any) -> Any:
+        if url.endswith("/v2/"):
+            return _HttpResponse(401, "OCI registry auth challenge")
+        if url.endswith("/state/health"):
+            return _HttpResponse(200, "health response")
+        if url.endswith("/openapi.json"):
+            return _HttpResponse(200, "OpenAPI document")
+        if url.endswith("/Hubs"):
+            return _HttpResponse(302, "login redirect when unauthenticated")
+        raise AssertionError(f"unexpected endpoint probe {url}")
+
+    monkeypatch.setattr(httpx, "get", fake_endpoint_get)
+    probe = OpsInventoryContextResolver().resolve("probe_services", None, source["params"])
+
+    posts: list[dict[str, Any]] = []
+
+    def fake_progress_get(url: str, **kwargs: Any) -> _JsonResponse:
+        return _JsonResponse([])
+
+    def fake_progress_post(url: str, **kwargs: Any) -> _JsonResponse:
+        posts.append({"url": url, **kwargs})
+        return _JsonResponse({"id": "progress-1"})
+
+    monkeypatch.setattr(httpx, "get", fake_progress_get)
+    monkeypatch.setattr(httpx, "post", fake_progress_post)
+
+    result = persist_ops_inventory_evidence(
+        {
+            "activity_id": definition.id,
+            "run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+            "scheduled_for": "2026-06-05T10:15:00+00:00",
+            "version_used": 1,
+            "context_sources": [source],
+            "context": {"ops_inventory_probe": probe},
+        }
+    )
+
+    assert definition.enabled is False
+    assert result[0]["status"] == "posted"
+    assert posts[0]["json"]["event_type"] == "ops_inventory_probe"
+    assert posts[0]["json"]["detail"]["probe"]["summary"]["ok"] == 4
+
+
+class _HttpResponse:
+    def __init__(self, status_code: int, text: str) -> None:
+        self.status_code = status_code
+        self.text = text
+
+
+class _JsonResponse:
+    def __init__(self, payload: Any) -> None:
+        self.payload = payload
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self) -> Any:
+        return self.payload

tests/test_report_sinks.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import pytest
+
+from activity_core.report_sinks import persist_reports
+
+
+class DummyResponse:
+    def __init__(self, payload: Any) -> None:
+        self.payload = payload
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self) -> Any:
+        return self.payload
+
+
+def _payload(sinks: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "activity_id": "activity-1",
+        "run_id": "12345678-aaaa-bbbb-cccc-123456789abc",
+        "scheduled_for": "2026-05-19T05:20:00+00:00",
+        "reports": [
+            {
+                "instruction_id": "daily-triage-report",
+                "report": {
+                    "summary": "State Hub has loose ends.",
+                    "recommendations": [{"candidate": "CUST-WP-0045"}],
+                },
+                "sinks": sinks,
+                "prompt_hash": "abc123",
+                "model": "test-model",
+                "output_validated": True,
+                "review_required": False,
+                "validation_error": None,
+            }
+        ],
+    }
+
+
+def test_working_memory_sink_writes_idempotently(tmp_path) -> None:
+    payload = _payload([
+        {
+            "type": "working-memory",
+            "path": str(tmp_path),
+            "timezone": "Europe/Berlin",
+        }
+    ])
+
+    first = persist_reports(payload)
+    second = persist_reports(payload)
+
+    assert first[0]["status"] == "written"
+    assert second[0]["status"] == "exists"
+    note = tmp_path / "daily-triage-2026-05-19-12345678.md"
+    text = note.read_text(encoding="utf-8")
+    assert "activity_core_run_id: 12345678-aaaa-bbbb-cccc-123456789abc" in text
+    assert "output_validated: true" in text
+    assert "review_required: false" in text
+    assert "model: test-model" in text
+    assert "State Hub has loose ends." in text
+
+
+def test_working_memory_sink_refuses_canonical_custodian_path() -> None:
+    payload = _payload([
+        {
+            "type": "working-memory",
+            "path": "/home/worsch/the-custodian/workplans",
+        }
+    ])
+
+    with pytest.raises(RuntimeError, match="refusing to write report"):
+        persist_reports(payload)
+
+
+def test_state_hub_progress_sink_posts(monkeypatch) -> None:
+    posts: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        assert url == "http://state-hub.test/progress/"
+        return DummyResponse([])
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        posts.append({"url": url, **kwargs})
+        return DummyResponse({"id": "progress-1"})
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    result = persist_reports(_payload([
+        {
+            "type": "state-hub-progress",
+            "state_hub_url": "http://state-hub.test",
+            "event_type": "daily_triage",
+            "workstream_id": "workstream-1",
+        }
+    ]))
+
+    assert result == [
+        {
+            "type": "state-hub-progress",
+            "status": "posted",
+            "event_type": "daily_triage",
+            "progress_id": "progress-1",
+        }
+    ]
+    assert posts[0]["url"] == "http://state-hub.test/progress/"
+    assert posts[0]["json"]["workstream_id"] == "workstream-1"
+    assert posts[0]["json"]["detail"]["activity_core_run_id"] == payload_run_id()
+    assert posts[0]["json"]["detail"]["output_validated"] is True
+    assert posts[0]["json"]["detail"]["review_required"] is False
+
+
+def test_state_hub_progress_includes_prior_working_memory_path(
+    monkeypatch,
+    tmp_path,
+) -> None:
+    posts: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse([])
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        posts.append({"url": url, **kwargs})
+        return DummyResponse({"id": "progress-1"})
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    result = persist_reports(_payload([
+        {
+            "type": "working-memory",
+            "path": str(tmp_path),
+            "timezone": "Europe/Berlin",
+        },
+        {
+            "type": "state-hub-progress",
+            "state_hub_url": "http://state-hub.test",
+            "event_type": "daily_triage",
+        },
+    ]))
+
+    assert [entry["status"] for entry in result] == ["written", "posted"]
+    assert posts[0]["json"]["detail"]["working_memory_path"] == str(
+        tmp_path / "daily-triage-2026-05-19-12345678.md"
+    )
+    assert posts[0]["json"]["detail"]["working_memory_status"] == "written"
+
+
+def test_state_hub_progress_sink_is_idempotent(monkeypatch) -> None:
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse([
+            {
+                "event_type": "daily_triage",
+                "detail": {
+                    "activity_core_run_id": payload_run_id(),
+                    "instruction_id": "daily-triage-report",
+                },
+            }
+        ])
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        raise AssertionError("post should not be called")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    result = persist_reports(_payload([
+        {
+            "type": "state-hub-progress",
+            "state_hub_url": "http://state-hub.test",
+            "event_type": "daily_triage",
+        }
+    ]))
+
+    assert result[0]["status"] == "exists"
+
+
+def payload_run_id() -> str:
+    return "12345678-aaaa-bbbb-cccc-123456789abc"

tests/test_rule_evaluation_activity.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import pytest
+
+from activity_core import activities
+
+
+@pytest.mark.asyncio
+async def test_evaluate_rules_returns_interpolated_task_specs() -> None:
+    result = await activities.evaluate_rules({
+        "rules": [
+            {
+                "id": "flag-stale-sbom",
+                "for_each": "context.repos.repos",
+                "bind_as": "repo",
+                "condition": "context.repo.sbom_age_days > 30",
+                "action": {
+                    "task_template": "Run SBOM rescan for {context.repo.repo_slug}",
+                    "target_repo": "context.repo.repo_slug",
+                    "priority": "medium",
+                    "labels": ["sbom", "{context.repo.repo_slug}"],
+                },
+            }
+        ],
+        "event": {},
+        "context": {
+            "repos": {
+                "repos": [
+                    {"repo_slug": "fresh-repo", "sbom_age_days": 5},
+                    {"repo_slug": "stale-repo", "sbom_age_days": 40},
+                ]
+            }
+        },
+    })
+
+    assert len(result) == 1
+    assert result[0]["title"] == "Run SBOM rescan for stale-repo"
+    assert result[0]["target_repo"] == "stale-repo"
+    assert result[0]["labels"] == ["sbom", "stale-repo"]
+    assert result[0]["condition"] == "context.repo.sbom_age_days > 30"

tests/test_schedule_lifecycle.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import asyncio
 import uuid
+from datetime import datetime, timedelta, timezone
 
 import pytest
 from temporalio.client import ScheduleOverlapPolicy
@@ -21,8 +22,11 @@ from temporalio.testing import WorkflowEnvironment
 from activity_core.models import ActivityDefinition, CronTriggerConfig
 from activity_core.schedule_manager import (
     delete_schedule,
+    delete_smoke_test_schedule,
     list_schedules,
     schedule_id,
+    schedule_smoke_test,
+    smoke_schedule_id,
     upsert_schedule,
 )
 
@@ -125,9 +129,15 @@ async def test_delete_schedule_removes_schedule(env: WorkflowEnvironment) -> Non
     await upsert_schedule(env.client, defn)
     await delete_schedule(env.client, defn.id)
 
-    schedules = await list_schedules(env.client)
+    sid = schedule_id(defn.id)
-    ids = [s["schedule_id"] for s in schedules]
+    ids: list[str] = []
-    assert schedule_id(defn.id) not in ids, "Schedule should be gone after delete"
+    for _ in range(10):
+        schedules = await list_schedules(env.client)
+        ids = [s["schedule_id"] for s in schedules]
+        if sid not in ids:
+            break
+        await asyncio.sleep(0.3)
+    assert sid not in ids, "Schedule should be gone after delete"
 
 
 # ── T25e: delete_schedule is idempotent (no-op for non-existent schedule) ────
@@ -174,3 +184,30 @@ async def test_misfire_policy_compress_sets_overlap_buffer_one(env: WorkflowEnvi
     assert desc.schedule.policy.overlap == ScheduleOverlapPolicy.BUFFER_ONE
 
     await delete_schedule(env.client, defn.id)
+
+
+@pytest.mark.asyncio
+async def test_schedule_smoke_test_creates_one_shot_schedule(
+    env: WorkflowEnvironment,
+) -> None:
+    defn = _make_defn()
+    fire_base = datetime(2026, 6, 6, 12, 0, tzinfo=timezone.utc)
+
+    sid, workflow_id, fire_at = await schedule_smoke_test(
+        env.client,
+        defn,
+        delay=timedelta(minutes=1),
+        now=fire_base,
+    )
+
+    assert sid == smoke_schedule_id(defn.id)
+    assert workflow_id == f"activity-{defn.id}:smoke-20260606T120100Z"
+    assert fire_at == datetime(2026, 6, 6, 12, 1, tzinfo=timezone.utc)
+
+    handle = env.client.get_schedule_handle(sid)
+    desc = await handle.describe()
+    assert desc.schedule.state.limited_actions is True
+    assert desc.schedule.state.remaining_actions == 1
+    assert desc.schedule.spec.time_zone_name == "UTC"
+
+    await delete_smoke_test_schedule(env.client, defn.id)

tests/test_schedule_smoke_script.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+
+def _load_script():
+    path = Path(__file__).parent.parent / "scripts" / "smoke_test_schedule.py"
+    spec = importlib.util.spec_from_file_location("smoke_test_schedule", path)
+    assert spec is not None
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_schedule_smoke_script_dry_run_contract() -> None:
+    script = _load_script()
+    args = script.parse_args([
+        "--activity-id",
+        "00000000-0000-0000-0000-000000000123",
+        "--recreate-recurring",
+        "--dry-run",
+    ])
+
+    report = script.build_dry_run_report(args)
+
+    assert report["mode"] == "dry-run"
+    assert report["activity_id"] == "00000000-0000-0000-0000-000000000123"
+    assert report["recreate_recurring"] is True
+    assert report["delay_seconds"] == 60
+    assert "create a one-shot smoke Temporal Schedule one minute in the future" in report["checks"]

tests/test_state_hub_context_resolver.py

@@ -0,0 +1,468 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+import pytest
+
+from activity_core.context_resolvers.state_hub import StateHubContextResolver
+
+
+class DummyResponse:
+    def __init__(self, payload: Any, status_error: Exception | None = None) -> None:
+        self.payload = payload
+        self.status_error = status_error
+
+    def raise_for_status(self) -> None:
+        if self.status_error is not None:
+            raise self.status_error
+
+    def json(self) -> Any:
+        return self.payload
+
+
+def test_state_summary_query(monkeypatch) -> None:
+    calls: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        return DummyResponse({"tasks": {"todo": 3}})
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test")
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = StateHubContextResolver().resolve("state_summary", None, {})
+
+    assert result == {"tasks": {"todo": 3}}
+    assert calls == [
+        {
+            "url": "http://state-hub.test/state/summary",
+            "params": None,
+            "timeout": 10.0,
+        }
+    ]
+
+
+def test_daily_triage_queries(monkeypatch) -> None:
+    calls: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        return DummyResponse({"url": url, "params": kwargs.get("params")})
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test/")
+    monkeypatch.setattr(httpx, "get", fake_get)
+    resolver = StateHubContextResolver()
+
+    resolver.resolve("next_steps", None, {})
+    resolver.resolve("workplan_index", None, {"refresh": False})
+    resolver.resolve("hub_inbox", None, {"to_agent": "hub", "unread_only": True})
+
+    assert calls == [
+        {
+            "url": "http://state-hub.test/state/next_steps",
+            "params": None,
+            "timeout": 10.0,
+        },
+        {
+            "url": "http://state-hub.test/workstreams/workplan-index",
+            "params": {"refresh": False},
+            "timeout": 10.0,
+        },
+        {
+            "url": "http://state-hub.test/messages/",
+            "params": {"to_agent": "hub", "unread_only": True},
+            "timeout": 10.0,
+        },
+    ]
+
+
+def test_existing_queries_still_resolve(monkeypatch) -> None:
+    calls: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        if url.endswith("/state/domain/custodian"):
+            return DummyResponse({"ok": True})
+        if url.endswith("/sbom/activity-core"):
+            return DummyResponse({
+                "repo_slug": "activity-core",
+                "last_sbom_at": "2026-04-26T11:37:56+00:00",
+                "entry_count": 38,
+                "entries": [],
+            })
+        raise AssertionError(f"unexpected url {url}")
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test")
+    monkeypatch.setattr(httpx, "get", fake_get)
+    resolver = StateHubContextResolver()
+
+    assert resolver.resolve("domain_summary", None, {"domain": "custodian"}) == {"ok": True}
+
+    sbom = resolver.resolve("repo_sbom_status", None, {"repo_slug": "activity-core"})
+    assert sbom["repo_slug"] == "activity-core"
+    assert sbom["has_sbom"] is True
+    assert sbom["last_sbom_at"] == "2026-04-26T11:37:56+00:00"
+    assert isinstance(sbom["sbom_age_days"], int) and sbom["sbom_age_days"] >= 0
+
+    assert [c["url"] for c in calls] == [
+        "http://state-hub.test/state/domain/custodian",
+        "http://state-hub.test/sbom/activity-core",
+    ]
+
+
+def test_repo_sbom_status_bulk_returns_worst_repo(monkeypatch) -> None:
+    calls: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        return DummyResponse([
+            {"slug": "fresh-repo", "last_sbom_at": "2099-01-01T00:00:00+00:00"},
+            {"slug": "stale-repo", "last_sbom_at": "2024-01-01T00:00:00+00:00"},
+            {"slug": "never-scanned", "last_sbom_at": None},
+        ])
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test")
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = StateHubContextResolver().resolve(
+        "repo_sbom_status", None, {"repos": "all"}
+    )
+
+    assert calls == [
+        {"url": "http://state-hub.test/repos/", "params": None, "timeout": 10.0},
+    ]
+    assert result["total_count"] == 3
+    # both stale-repo and never-scanned exceed the 30-day staleness threshold
+    assert result["stale_count"] == 2
+    assert result["worst_repo_slug"] == "never-scanned"
+    assert result["worst_age_days"] == 99999
+
+    by_slug = {entry["repo_slug"]: entry for entry in result["repos"]}
+    assert by_slug["fresh-repo"]["has_sbom"] is True
+    assert by_slug["fresh-repo"]["sbom_age_days"] == 0
+    assert by_slug["never-scanned"]["has_sbom"] is False
+    assert by_slug["never-scanned"]["last_sbom_at"] is None
+
+
+def test_repo_sbom_status_returns_empty_on_failure(monkeypatch) -> None:
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse(None, status_error=httpx.HTTPError("boom"))
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test")
+    monkeypatch.setattr(httpx, "get", fake_get)
+    resolver = StateHubContextResolver()
+
+    assert resolver.resolve("repo_sbom_status", None, {"repo_slug": "x"}) == {}
+    assert resolver.resolve("repo_sbom_status", None, {"repos": "all"}) == {}
+
+
+def test_coding_retro_returns_latest_progress_suggestions(monkeypatch) -> None:
+    calls: list[dict[str, Any]] = []
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        return DummyResponse([
+            {
+                "id": "older-retro",
+                "event_type": "coding_retro",
+                "summary": "older",
+                "created_at": "2026-05-31T17:00:00Z",
+                "detail": {
+                    "generated_at": "2026-05-31T17:00:00Z",
+                    "suggestions": [
+                        {
+                            "repo": "old-repo",
+                            "title": "Old recommendation",
+                            "recommendation": "Do the older thing.",
+                            "priority": "low",
+                            "score": 1,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": "note-1",
+                "event_type": "note",
+                "summary": "ignore me",
+                "created_at": "2026-06-07T17:05:00Z",
+                "detail": {},
+            },
+            {
+                "id": "newer-retro",
+                "event_type": "coding_retro",
+                "summary": "weekly coding retro ready",
+                "created_at": "2026-06-07T17:10:00Z",
+                "detail": {
+                    "generated_at": "2026-06-07T17:09:30Z",
+                    "window": {
+                        "since": "2026-05-31T00:00:00Z",
+                        "until": "2026-06-07T00:00:00Z",
+                    },
+                    "suggestions": [
+                        {
+                            "target_repo": "activity-core",
+                            "title": "Harden schedule smoke gates",
+                            "description": "Add a smoke proof before enablement.",
+                            "priority": "HIGH",
+                            "score": "8.5",
+                        },
+                        {
+                            "repo_slug": "repo-without-title",
+                            "recommendation": "missing title should be skipped",
+                            "score": 9,
+                        },
+                    ],
+                },
+            },
+        ])
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test/")
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = StateHubContextResolver().resolve(
+        "coding_retro",
+        None,
+        {"limit": 20, "window_days": 7},
+    )
+
+    assert calls == [
+        {
+            "url": "http://state-hub.test/progress/",
+            "params": {"limit": 20},
+            "timeout": 10.0,
+        }
+    ]
+    assert result["source_progress_id"] == "newer-retro"
+    assert result["generated_at"] == "2026-06-07T17:09:30Z"
+    assert result["window"] == {
+        "since": "2026-05-31T00:00:00Z",
+        "until": "2026-06-07T00:00:00Z",
+    }
+    assert result["summary"] == "weekly coding retro ready"
+    assert result["suggestions"] == [
+        {
+            "repo": "activity-core",
+            "title": "Harden schedule smoke gates",
+            "recommendation": "Add a smoke proof before enablement.",
+            "priority": "high",
+            "score": 8.5,
+        }
+    ]
+
+
+def test_coding_retro_returns_empty_shape_when_not_published(monkeypatch) -> None:
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse([
+            {
+                "id": "note-1",
+                "event_type": "note",
+                "created_at": "2026-06-07T17:10:00Z",
+            }
+        ])
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    result = StateHubContextResolver().resolve(
+        "coding_retro",
+        None,
+        {"event_type": "coding_retro"},
+    )
+
+    assert result == {
+        "suggestions": [],
+        "window": None,
+        "generated_at": None,
+        "source_progress_id": None,
+        "event_type": "coding_retro",
+        "summary": "",
+    }
+
+
+def test_resolver_failure_returns_empty(monkeypatch) -> None:
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        raise httpx.ConnectError("offline")
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    assert StateHubContextResolver().resolve("state_summary", None, {}) == {}
+
+
+def test_unknown_query_returns_empty() -> None:
+    assert StateHubContextResolver().resolve("unknown", None, {}) == {}
+
+
+def test_recently_on_scope_hourly_posts_batch(monkeypatch) -> None:
+    calls: list[dict[str, Any]] = []
+
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        calls.append({"url": url, **kwargs})
+        return DummyResponse(
+            {
+                "generated": [{"domain_slug": "custodian"}],
+                "skipped": [],
+                "failed": [],
+            }
+        )
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test/")
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    result = StateHubContextResolver().resolve(
+        "recently_on_scope_hourly",
+        None,
+        {
+            "range": "1h",
+            "active_only": True,
+            "include_attention": False,
+            "required": True,
+        },
+    )
+
+    assert result == {
+        "generated": [{"domain_slug": "custodian"}],
+        "skipped": [],
+        "failed": [],
+    }
+    assert calls == [
+        {
+            "url": "http://state-hub.test/recently-on-scope/hourly",
+            "json": {"range": "1h", "active_only": True, "include_attention": False},
+            "timeout": 10.0,
+        }
+    ]
+
+
+def test_recently_on_scope_hourly_failure_bubbles(monkeypatch) -> None:
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        raise httpx.ConnectError("offline")
+
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    with pytest.raises(httpx.ConnectError):
+        StateHubContextResolver().resolve("recently_on_scope_hourly", None, {"range": "1h"})
+
+
+def test_recently_on_scope_hourly_rejects_empty_response(monkeypatch) -> None:
+    def fake_post(url: str, **kwargs: Any) -> DummyResponse:
+        return DummyResponse({})
+
+    monkeypatch.setattr(httpx, "post", fake_post)
+
+    with pytest.raises(RuntimeError, match="missing required key"):
+        StateHubContextResolver().resolve("recently_on_scope_hourly", None, {"range": "1h"})
+
+
+def test_daily_triage_digest_is_curated_scalar_json(monkeypatch) -> None:
+    payloads = {
+        "/state/summary": {
+            "generated_at": "2026-05-19T05:20:00Z",
+            "totals": {"tasks": {"todo": 4, "wait": 1}},
+            "topics": [
+                {
+                    "slug": "custodian",
+                    "domain_slug": "custodian",
+                    "workstreams": [
+                        {
+                            "id": "ws-1",
+                            "slug": "cust-wp-0045",
+                            "title": "Activity-Core Daily Triage Runner Cutover",
+                            "status": "ready",
+                            "owner": "custodian",
+                        },
+                        {
+                            "id": "ws-closed",
+                            "slug": "closed",
+                            "title": "Closed",
+                            "status": "finished",
+                            "owner": "custodian",
+                        },
+                    ],
+                }
+            ],
+        },
+        "/workstreams/workplan-index": {
+            "workstreams": {
+                "ws-1": {
+                    "repo_slug": "the-custodian",
+                    "relative_path": "workplans/CUST-WP-0045.md",
+                    "needs_review": True,
+                    "health_labels": ["needs_review"],
+                }
+            }
+        },
+        "/state/next_steps": [
+            {
+                "type": "resolved_decision",
+                "domain": "custodian",
+                "workstream_id": "ws-1",
+                "workstream_slug": "cust-wp-0045",
+                "workstream_title": "Activity-Core Daily Triage Runner Cutover",
+                "task_id": "task-1",
+                "task_title": "T05 - Update ActivityDefinition",
+                "message": "free text should not be included",
+            }
+        ],
+        "/messages/": [
+            {
+                "id": "msg-1",
+                "from_agent": "hub",
+                "subject": "Please review",
+                "body": "free text should not be included",
+                "created_at": "2026-05-19T05:00:00Z",
+            }
+        ],
+        "/workstreams/ws-1": {
+            "planning_priority": "high",
+            "planning_order": 45,
+        },
+        "/tasks/": [
+            {
+                "id": "task-1",
+                "title": "T05 - Update ActivityDefinition",
+                "status": "todo",
+                "priority": "high",
+                "needs_human": False,
+                "description": "free text should not be included",
+            },
+            {
+                "id": "task-2",
+                "title": "T06 - Canary Cutover",
+                "status": "wait",
+                "priority": "medium",
+                "needs_human": True,
+            },
+        ],
+    }
+
+    def fake_get(url: str, **kwargs: Any) -> DummyResponse:
+        path = url.removeprefix("http://state-hub.test")
+        return DummyResponse(payloads[path])
+
+    monkeypatch.setenv("STATE_HUB_URL", "http://state-hub.test")
+    monkeypatch.setattr(httpx, "get", fake_get)
+
+    raw_digest = StateHubContextResolver().resolve(
+        "daily_triage_digest",
+        None,
+        {"max_workstreams": 4, "max_next_steps": 4},
+    )
+
+    assert isinstance(raw_digest, str)
+    assert "free text should not be included" not in raw_digest
+
+    import json
+    digest = json.loads(raw_digest)
+    assert digest["totals"] == {"tasks": {"todo": 4, "wait": 1}}
+    assert digest["open_workstreams"][0]["slug"] == "cust-wp-0045"
+    assert digest["open_workstreams"][0]["planning_priority"] == "high"
+    assert digest["open_workstreams"][0]["open_task_counts"] == {
+        "wait": 1,
+        "todo": 1,
+        "progress": 0,
+        "needs_human": 1,
+        "open_total": 2,
+    }
+    assert digest["deterministic_scoring"]["future_mode"] == (
+        "code_score_high_gain_high_effort_candidates"
+    )

tests/test_sync_activity_definitions.py

@@ -0,0 +1,97 @@
+import uuid
+
+from activity_core.definition_parser import scan_and_parse
+from activity_core.models import ActivityDefinition
+from activity_core.sync_activity_definitions import _definition_uuid
+
+
+def test_definition_uuid_preserves_uuid_ids() -> None:
+    raw_id = "6fca51fa-387a-4fd0-bc4e-d62c29eb859a"
+
+    assert _definition_uuid(raw_id) == uuid.UUID(raw_id)
+
+
+def test_definition_uuid_maps_slug_ids_stably() -> None:
+    first = _definition_uuid("weekly-sbom-staleness")
+    second = _definition_uuid("weekly-sbom-staleness")
+
+    assert first == second
+    assert first.version == 5
+
+
+def test_activity_definition_accepts_adr_style_context_source_without_name() -> None:
+    defn = ActivityDefinition.model_validate(
+        {
+            "id": "6fca51fa-387a-4fd0-bc4e-d62c29eb859a",
+            "name": "Daily State Hub WSJF Triage",
+            "enabled": False,
+            "trigger_config": {
+                "trigger_type": "cron",
+                "cron_expression": "20 7 * * *",
+                "timezone": "Europe/Berlin",
+                "misfire_policy": "skip",
+            },
+            "context_sources": [
+                {
+                    "type": "state-hub",
+                    "query": "daily_triage_digest",
+                    "bind_to": "context.daily_triage_digest",
+                }
+            ],
+        }
+    )
+
+    assert defn.context_sources[0].name == ""
+
+
+def test_scan_and_parse_reads_external_activity_definition_dirs(
+    tmp_path,
+    monkeypatch,
+) -> None:
+    repo_root = tmp_path / "activity-core"
+    external_root = tmp_path / "the-custodian"
+    definitions_dir = external_root / "activity-definitions"
+    repo_root.mkdir()
+    definitions_dir.mkdir(parents=True)
+    (definitions_dir / "ops-service-inventory-probes.md").write_text(
+        """---
+id: "40d15a87-7ff6-4d8e-992c-37df15f95110"
+name: "Ops Service Inventory Probes"
+enabled: false
+owner: custodian
+governance: custodian
+status: proposed
+trigger:
+  type: cron
+  cron_expression: "15 * * * *"
+  timezone: Europe/Berlin
+  misfire_policy: skip
+context_sources:
+  - type: ops-inventory
+    query: probe_services
+    bind_to: context.ops_probe
+    params:
+      inventory_path: /tmp/service-inventory.yml
+      evidence_sinks:
+        - type: state-hub-progress
+          event_type: ops_inventory_probe
+---
+
+# Ops Service Inventory Probes
+""",
+        encoding="utf-8",
+    )
+
+    monkeypatch.chdir(repo_root)
+    monkeypatch.setenv("ACTIVITY_DEFINITION_DIRS", str(external_root))
+
+    definitions = scan_and_parse()
+
+    assert len(definitions) == 1
+    definition = definitions[0]
+    assert definition.name == "Ops Service Inventory Probes"
+    assert definition.enabled is False
+    assert definition.context_sources[0]["type"] == "ops-inventory"
+    assert definition.context_sources[0]["params"]["evidence_sinks"][0]["type"] == (
+        "state-hub-progress"
+    )

workplans/ACTIVITY-WP-0005-railiance01-production-service.md

@@ -0,0 +1,63 @@
+---
+id: ACTIVITY-WP-0005
+type: workplan
+title: "Railiance01 production service"
+domain: custodian
+repo: activity-core
+status: finished
+owner: codex
+topic_slug: custodian
+created: "2026-05-22"
+updated: "2026-05-22"
+state_hub_workstream_id: "5b1e98a0-1d5d-41bd-a44e-c82502b5a60d"
+---
+
+# ACTIVITY-WP-0005 - Railiance01 Production Service
+
+## Review Railiance Runtime
+
+```task
+id: ACTIVITY-WP-0005-T01
+status: done
+priority: high
+state_hub_task_id: "0247ebd0-7f94-41d1-8439-abfa21e4466d"
+```
+
+Confirm railiance01 access, operating system, container runtime, and cluster
+shape before selecting the production deployment path.
+
+## Add Kubernetes Deployment Bundle
+
+```task
+id: ACTIVITY-WP-0005-T02
+status: done
+priority: high
+state_hub_task_id: "5689510b-c41f-46c9-844e-6f619473e50d"
+```
+
+Create a K3s-native deployment bundle for activity-core, including infrastructure,
+runtime jobs, API, worker, event router, and generated Kubernetes secrets.
+
+## Build And Import Production Image
+
+```task
+id: ACTIVITY-WP-0005-T03
+status: done
+priority: high
+state_hub_task_id: "605ca0bf-733b-41c0-ad36-d3c3560f77cf"
+```
+
+Build the production image locally, transfer it to railiance01, and import it
+into the K3s containerd image store.
+
+## Apply And Verify Service
+
+```task
+id: ACTIVITY-WP-0005-T04
+status: done
+priority: high
+state_hub_task_id: "66bbc149-6d81-48e5-8f0e-7909353dc22c"
+```
+
+Apply the manifests on railiance01, run migrations and sync jobs, then verify
+the API health endpoint and core pods.

workplans/ACTIVITY-WP-0006-post-triage-operational-hardening.md

@@ -0,0 +1,256 @@
+---
+id: ACTIVITY-WP-0006
+type: workplan
+title: "Post-triage operational hardening"
+domain: custodian
+repo: activity-core
+status: active
+owner: codex
+topic_slug: custodian
+created: "2026-06-03"
+updated: "2026-06-07"
+state_hub_workstream_id: "5646e13a-13af-4724-bca6-3c0d86f96733"
+---
+
+# ACTIVITY-WP-0006 — Post-triage operational hardening
+
+## Context
+
+activity-core has crossed the main construction threshold: Temporal-backed
+schedules, context resolution, deterministic rules, LLM instructions, report
+sinks, and the Railiance production service are implemented. The daily State
+Hub WSJF triage cutover is now trusted enough that activity-core can be treated
+as the standing scheduled substrate rather than an experiment.
+
+The next work should keep that substrate dependable and aligned with
+`INTENT.md`: activity-core owns when coordination work runs, what task/report
+outputs are produced, and where they are emitted. It must not grow into the
+task lifecycle database, a project planner, or an execution worker.
+
+## Task Status Canon Adaptation
+
+```task
+id: ACTIVITY-WP-0006-T01
+status: done
+priority: high
+state_hub_task_id: "5d79e3da-d26d-4cad-9cdf-5e5264bb7019"
+```
+
+Adapt activity-core to State Hub's task status canon:
+`wait`, `todo`, `progress`, `done`, `cancel`.
+
+Scope:
+- update `AGENTS.md` task-status examples and progression text
+- update State Hub context resolver task-status filters and digest counters
+- keep workstream/workplan lifecycle status separate; `blocked` remains valid
+  for workstreams/workplans where State Hub still uses it
+- update tests that fixture or assert `in_progress` / task-level `blocked`
+- resolve the State Hub interface-change notice only after the repo is adapted
+
+Done when the full test suite passes and activity-core no longer depends on
+legacy task-status aliases for State Hub API clients or tests.
+
+2026-06-04: Completed. `AGENTS.md` now uses State Hub task statuses
+`wait`, `todo`, `progress`, `done`, and `cancel`; workplan/workstream lifecycle
+`blocked` remains separate. The State Hub daily triage digest now counts
+`wait/todo/progress` open tasks and no longer fixtures task-level
+`in_progress` or `blocked`. Full suite passed: 128 passed, 1 skipped.
+
+## Daily Triage Observability Runbook
+
+```task
+id: ACTIVITY-WP-0006-T02
+status: done
+priority: high
+state_hub_task_id: "02c34443-0e8d-4f1a-93d9-6c39f07faad7"
+```
+
+Document and, where cheap, automate how to answer "did today's daily triage
+run happen?"
+
+The operator should be able to check:
+- Temporal schedule state and latest workflow history
+- `activity_runs` row for the daily triage ActivityDefinition
+- State Hub `daily_triage` progress event
+- working-memory report note
+- expected missed-run behavior (`skip`, not catch-up)
+- the configured LLM and Temporal timeout relationship
+
+Done when `docs/runbook.md` has a concise daily-triage verification section
+and any helper command/script is covered by tests or a dry-run path.
+
+2026-06-04: Completed. Added `scripts/verify_daily_triage.py` with dry-run and
+live modes, plus `tests/test_daily_triage_verifier.py`. `docs/runbook.md` now
+covers Temporal schedule/workflow checks, `activity_runs`, State Hub progress,
+working-memory notes, missed-run `skip` behavior, and LLM timeout budget.
+
+2026-06-05: Follow-up hardening after the scheduled WSJF triage ran but emitted
+no report because the live schema required `wsjf` fields and the stale DB prompt
+did not request them. The verifier default and runbook now point at the live
+working-memory sink path, `/home/worsch/the-custodian/memory/working`.
+
+2026-06-06: Added a schedule smoke-test routine for new or changed recurring
+ActivityDefinitions. Operators can recreate the recurring Temporal Schedule,
+schedule a one-shot smoke run one minute in the future, wait for completion,
+and get a non-zero warning if workflow imports, activity registration, or
+runtime wiring are broken.
+
+2026-06-06: Exercised the routine against the daily triage definition. The
+daily recurring Temporal Schedule was deleted and recreated, then a one-shot
+smoke workflow completed with run id `c2db32e5-3874-522f-ae1f-9b2cdf307fd2`
+and emitted a validated `daily_triage` report plus working-memory note.
+
+## Three-Run Calibration Feedback
+
+```task
+id: ACTIVITY-WP-0006-T03
+status: wait
+priority: medium
+state_hub_task_id: "7cbf0a35-71a1-47ac-afc2-f51ad2180fd0"
+```
+
+Collect three consecutive scheduled activity-core daily triage runs and feed
+the result back into the Custodian WSJF calibration loop.
+
+Assess:
+- whether the top recommendations matched actual useful follow-up work
+- report length and density
+- loose-end detection sensitivity
+- stale-but-intentionally-parked work handling
+- whether model settings or prompt/schema constraints need adjustment
+
+Done when the calibration result is recorded in State Hub and the related
+`CUST-WP-0044` / `CUST-WP-0045` tasks can close based on activity-core runs,
+not Codex app fallback runs.
+
+2026-06-04: Waiting on real evidence. The repo now has a verification path for
+scheduled daily triage runs, but this task still requires three consecutive
+actual activity-core scheduled runs and State Hub calibration feedback. Local
+tests cannot substitute for that operational evidence.
+
+2026-06-06: The scheduled run fired at 07:20 Europe/Berlin but initially stuck
+on a stale worker import error after ops-evidence wiring landed. Restarting the
+worker let Temporal complete the run, and the hardened report path emitted a
+validation-failure note instead of losing the evidence. This run is useful
+calibration input, but it is not a clean consecutive scheduled success.
+
+2026-06-07: Investigated the missing June 7 WSJF result. State Hub had no
+`daily_triage` event for the date, no local activity-core DB/Temporal/API ports
+were reachable, and the current Railiance Kubernetes context had no
+`activity-core` namespace. The Railiance runtime projection also lacked
+`daily-statehub-wsjf-triage.md`, and the node-local State Hub bridge target
+`127.0.0.1:18000` returned connection reset. Patched activity-core to project
+the daily definition, mount the schema and working-memory storage, expose
+`LLM_CONNECT_URL`, include `working_memory_path` in State Hub progress detail,
+and emit a visible `execution_failed` report for report-sink instructions when
+llm-connect is missing or broken. Cross-repo closure tasks were posted via
+State Hub to `state-hub` (`dc10704f`), `railiance-cluster` (`53e78702`),
+`llm-connect` (`cf758ed8`), `the-custodian` (`7a5d4e62`), and
+`activity-core` (`28d11021`). This task remains waiting on a deployed, healthy
+activity-core runner plus three clean scheduled daily runs and calibration
+feedback.
+
+## Rule Action Contract Documentation
+
+```task
+id: ACTIVITY-WP-0006-T04
+status: done
+priority: medium
+state_hub_task_id: "c9066d2e-0429-4e14-a68a-8418061ffd8d"
+```
+
+Document the rule action contract introduced by the ADHOC-2026-06-01 work:
+whole-field `context.*` / `event.*` paths, scalar `{context.foo}` placeholders,
+and explicit `for_each` / `bind_as` per-item expansion.
+
+Also decide and document the naming/semantics mismatch around
+`action.task_template`: today it is the emitted task title field, while
+`tasks/*.md` contains template files with their own title templates.
+
+Done when ADR-003 or a focused follow-up doc contains examples, unsafe cases,
+and the weekly SBOM staleness definition is cited as the canonical pattern.
+
+2026-06-04: Completed. Updated ADR-003 with whole-field path rendering,
+scalar placeholder rendering, unsafe action cases, explicit `for_each` /
+`bind_as` expansion, the `task_template` naming mismatch, and weekly SBOM
+staleness as the canonical per-item pattern.
+
+## Production Alerting And Failure Modes
+
+```task
+id: ACTIVITY-WP-0006-T05
+status: done
+priority: medium
+state_hub_task_id: "420ea629-0c20-4d09-9cc1-6b2f32665161"
+```
+
+Turn the current confidence in the daily triage schedule into routine
+operational visibility.
+
+Cover:
+- Kubernetes/Temporal worker health expectations
+- schedule paused/missing detection
+- report sink failure behavior
+- LLM timeout and retry behavior
+- what should page, what should only leave a progress note, and what should be
+  handled in the next operator session
+
+Done when the runbook and metrics/health surface make ordinary failures visible
+without inspecting a Codex Desktop session.
+
+2026-06-04: Completed. `docs/runbook.md` now documents Kubernetes worker/API/
+router health checks, Temporal schedule paused/missing checks, report sink
+failure behavior, LLM timeout/retry behavior, and page/note/next-session
+classification. Task emission sink failures now raise from `emit_tasks`, making
+them visible to Temporal retries instead of warning-only logs.
+
+2026-06-05: Added instruction-output robustness for report-sink instructions:
+after retry exhaustion, schema-invalid model output now produces a durable
+validation-failure report containing bounded partial output instead of a silent
+empty result. Report sinks include validation metadata in working-memory
+frontmatter and State Hub progress detail.
+
+2026-06-06: Hardened instruction output parsing to accept a single Markdown
+JSON fence when the fenced content is valid JSON, while preserving the
+validation-failure artifact path for genuinely invalid output.
+
+## Issue-Core Emission Boundary Verification
+
+```task
+id: ACTIVITY-WP-0006-T06
+status: done
+priority: medium
+state_hub_task_id: "78089aef-aba1-42d7-a203-ef80ba6791d9"
+```
+
+Verify the downstream task emission boundary now that rule fan-out is real.
+
+Questions to close:
+- which issue-core endpoint is authoritative for task creation in the current
+  environment
+- whether `IssueCoreRestSink` should keep using REST or move to the intended
+  NATS subscription path
+- whether emitted rule tasks carry enough title, description, labels,
+  source id, condition, and target repo data for issue-core and operators
+- whether weekly SBOM staleness can be safely enabled against the real sink
+
+Done when there is a tested or dry-run-verified path from a rule match to a
+downstream task reference, and activity-core still owns only the spawn audit
+trail, not task lifecycle state.
+
+2026-06-04: Completed. Added `docs/issue-core-emission-boundary.md` documenting
+REST `/issues/` as the current authoritative endpoint, NATS as future work,
+Railiance `ISSUE_SINK_TYPE=null` dry-run mode, and the fields sent to
+issue-core versus retained in `task_spawn_log`. Added REST payload and sink
+failure tests in `tests/test_issue_sink.py`; the existing weekly SBOM integration
+test remains the dry-run rule-match-to-task-reference proof.
+
+## Completion Criteria
+
+- State Hub task-status canon adaptation is complete.
+- Daily triage has an operator-grade verification path and three-run
+  calibration evidence.
+- Rule action semantics are documented and no longer surprising.
+- Production failure modes are observable enough for routine operation.
+- Downstream task emission has been verified without expanding activity-core's
+  ownership boundary.

workplans/ACTIVITY-WP-0007-ops-inventory-probe-runner.md

@@ -0,0 +1,287 @@
+---
+id: ACTIVITY-WP-0007
+type: workplan
+title: "Ops Inventory Probe Runner"
+domain: custodian
+repo: activity-core
+status: finished
+owner: codex
+topic_slug: custodian
+created: "2026-06-05"
+updated: "2026-06-15"
+state_hub_workstream_id: "c91a0946-92f9-4b41-8a92-005b29952916"
+---
+
+# ACTIVITY-WP-0007 - Ops Inventory Probe Runner
+
+## Context
+
+Custodian `CUST-WP-0047` introduced an inventory-first ops-hub slice: a
+non-secret service inventory file, a generated service catalog view, and a
+disabled draft ActivityDefinition for repeatable service inventory probes.
+State Hub message `d543c39c-1f04-4f1e-a1e4-0d5b40503525` handed the
+activity-core portion to this repo.
+
+The request fits activity-core only if it stays narrow. activity-core should
+provide scheduled policy, bounded context resolution, deterministic lightweight
+HTTP/HTTPS checks, and non-secret evidence emission. It must not become an ops
+executor, secret handler, Inter-Hub operator, k8s/ssh/tunnel runner, or service
+inventory authority.
+
+Existing activity-core capabilities that make this feasible:
+- cron/manual ActivityDefinitions and Temporal orchestration
+- external definition scanning via `ACTIVITY_DEFINITION_DIRS`
+- static context sources and pluggable context resolvers
+- State Hub context resolver and State Hub progress report sink pattern
+- working-memory sink, NATS/EventEnvelope routing, and event type registry
+
+Known gaps this workplan closes:
+- no `ops-inventory` resolver for `service-inventory.yml`
+- no deterministic endpoint/access-path probe result model
+- no non-LLM evidence sink for ops probe summaries
+- no ops evidence event definitions owned by activity-core
+- no Railiance projection for the Custodian probe definition or inventory input
+
+## Add Ops Inventory Context Resolver
+
+```task
+id: ACTIVITY-WP-0007-T01
+status: done
+priority: high
+state_hub_task_id: "dbe49dfb-f073-4245-8e86-d0355a6bb8bb"
+```
+
+Add a registered context resolver:
+
+- source type: `ops-inventory`
+- query: `probe_services`
+- params: `inventory_path`, `timeout_seconds`, `include_kinds`,
+  `allow_network`, `required`
+
+The resolver reads and validates a non-secret service inventory YAML file,
+initially `/home/worsch/the-custodian/ops/service-inventory.yml` when present.
+It produces compact structured output:
+
+```json
+{
+  "services": [],
+  "endpoints": [],
+  "summary": {"ok": 0, "degraded": 0, "down": 0, "skipped": 0},
+  "generated_at": "..."
+}
+```
+
+First implementation scope:
+- HTTP/HTTPS endpoint probes only
+- expected status and expected signal checks only
+- non-HTTP, k8s, ssh, tunnel, and authenticated access paths return
+  `skipped` / `unsupported`, not failed
+- missing optional inventory returns `{}` or a skipped summary unless the
+  context source is required
+- no response bodies, cookies, authorization headers, tokens, or command output
+  are stored
+
+Done when fixture-based resolver tests cover `ok`, expected-status mismatch,
+expected-signal mismatch, network/down, unsupported, and optional/required
+inventory failure behavior.
+
+2026-06-05: Completed the first resolver slice. Added
+`src/activity_core/context_resolvers/ops_inventory.py`, registered source type
+`ops-inventory`, and covered ok/degraded/down/skipped results plus required vs
+optional inventory failure and no-secret output behavior.
+
+## Add Ops Evidence Sink
+
+```task
+id: ACTIVITY-WP-0007-T02
+status: done
+priority: high
+state_hub_task_id: "c6b5f49d-6f05-4be9-a968-de42195170cb"
+```
+
+Add a deterministic non-LLM evidence sink for compact probe results.
+
+Initial sink behavior:
+- sink type: `state-hub-progress`
+- State Hub event type: `ops_inventory_probe`
+- idempotency key: `activity_core_run_id + service_id + endpoint_id/access_path_id + event_type`
+- detail contains compact non-secret results only
+- one summary progress event per run is acceptable for the first version
+
+Prepare the contract for later Inter-Hub submission without making it mandatory:
+- event names: `ops-service-observed`, `ops-endpoint-verified`,
+  `ops-access-path-checked`, `ops-backup-verified`, `ops-inventory-drift`
+- Inter-Hub mode requires `INTER_HUB_URL`, `OPS_HUB_KEY` from Secret, and
+  widget/capability mapping config
+- missing Inter-Hub config skips cleanly with an explicit sink result
+
+Done when sink idempotency, State Hub fallback posting, missing Inter-Hub
+config, and no-secret-leak behavior are covered by tests.
+
+2026-06-05: Completed the State Hub fallback sink slice. Added
+`src/activity_core/ops_evidence_sinks.py`, a `persist_ops_evidence` Temporal
+activity, workflow/worker wiring, idempotent `ops_inventory_probe` progress
+posting, missing-Inter-Hub-config skip behavior, and no-secret compaction tests.
+
+## Register Ops Evidence Event Definitions
+
+```task
+id: ACTIVITY-WP-0007-T03
+status: done
+priority: medium
+state_hub_task_id: "70eb470e-9b0a-448f-ae3a-f5b1bed49e04"
+```
+
+Add activity-core-owned event type definitions for ops evidence so producers
+and future widgets have a stable contract:
+
+- `ops-service-observed`
+- `ops-endpoint-verified`
+- `ops-access-path-checked`
+- `ops-backup-verified`
+- `ops-inventory-drift`
+
+Each definition must document:
+- publisher intent
+- non-secret attribute schema
+- idempotency fields
+- examples for success, degraded, down, skipped, and drift where applicable
+- explicit forbidden payload material: secrets, auth headers, cookies, raw
+  response bodies, command output, and token-like values
+
+Done when event registry tests or parser coverage prove the definitions are
+valid and reviewable.
+
+2026-06-05: Completed. Added the five ops evidence event definitions under
+`event-types/` and parser tests covering required fields and safety language.
+
+## Wire Custodian Definition Safely
+
+```task
+id: ACTIVITY-WP-0007-T04
+status: done
+priority: medium
+state_hub_task_id: "45132f9f-da3c-44f1-a488-195aa0e46428"
+```
+
+Accept the Custodian-owned disabled draft definition:
+
+`/home/worsch/the-custodian/activity-definitions/ops-service-inventory-probes.md`
+
+Requirements:
+- support sync/parse with
+  `ACTIVITY_DEFINITION_DIRS=/home/worsch/the-custodian`
+- keep the definition disabled until resolver, sink, and deployment wiring pass
+- add parser/sync tests for external definition directories
+- ensure manual trigger of a disabled definition in test/dev can produce fixture
+  evidence without enabling the production schedule
+
+Done when activity-core can scan the Custodian definition path without enabling
+it prematurely.
+
+2026-06-05: Started. Added test coverage that
+`ACTIVITY_DEFINITION_DIRS=/home/worsch/the-custodian` style external roots can
+scan a disabled `ops-service-inventory-probes.md` definition carrying an
+`ops-inventory` context source and explicit `state-hub-progress` evidence sink.
+
+2026-06-05: Completed. The Railiance-projected disabled definition now uses the
+`ops-inventory` resolver and explicit `state-hub-progress` evidence sink. Tests
+prove the disabled definition can resolve fixture inventory data and emit one
+compact `ops_inventory_probe` State Hub progress event without enabling the
+production schedule.
+
+## Wire Railiance Runtime Inputs
+
+```task
+id: ACTIVITY-WP-0007-T05
+status: done
+priority: medium
+state_hub_task_id: "474564be-a447-4bdf-b995-168f7a93e515"
+```
+
+Wire the production deployment only after the local resolver/sink tests pass.
+
+Scope:
+- project the new disabled Custodian definition into
+  `actcore-external-activity-definitions`
+- decide how the worker sees the inventory input:
+  - generated ConfigMap from `service-inventory.yml`
+  - mounted repo snapshot
+  - State Hub endpoint if Custodian later exposes the inventory
+- add config placeholders for `OPS_INVENTORY_PATH`, `INTER_HUB_URL`, and widget
+  mapping
+- keep `OPS_HUB_KEY` in Secret only
+
+Done when the Railiance worker can see the disabled definition and inventory
+input without leaking secrets or activating the schedule early.
+
+2026-06-05: Completed the first production wiring slice. `20-runtime.yaml`
+projects the disabled ops probe definition, runtime config placeholders
+(`OPS_INVENTORY_PATH`, `INTER_HUB_URL`, `OPS_HUB_WIDGET_MAPPING`), and a
+non-secret `actcore-ops-service-inventory` ConfigMap snapshot. The worker mounts
+the inventory at `/etc/activity-core/ops`, and `bootstrap-secrets.sh` keeps
+`OPS_HUB_KEY` as an empty Secret-only placeholder until operator provisioning.
+
+## Close Safety And Handoff Gates
+
+```task
+id: ACTIVITY-WP-0007-T06
+status: done
+priority: medium
+state_hub_task_id: "d15fc947-3fbe-4269-93c6-d98577352149"
+```
+
+Complete the operational handoff only after the safety gates are satisfied.
+
+Acceptance criteria:
+- a disabled manual trigger runs the ops inventory probe against fixture or
+  non-production inventory data and produces compact non-secret evidence
+- State Hub progress receives one `ops_inventory_probe` summary per run
+- Inter-Hub submission is either implemented behind config/secret gates or
+  explicitly deferred with a clean sink result
+- the activity-core worker can sync the Custodian definition without enabling it
+  prematurely
+- no k8s, ssh, tunnel, or authenticated command execution is required for the
+  first version
+- `CUST-WP-0047-T07` has enough evidence to move from `progress` toward done
+
+This task waits on the implementation tasks above and, for final Inter-Hub
+activation, the operator-gated ops-hub widget/API-key path in `CUST-WP-0047`.
+
+2026-06-05: The local implementation gates are now satisfied and tested. Live
+closure remains waiting on applying the updated Railiance manifests and on the
+operator-gated Inter-Hub ops-hub widget/API-key path.
+
+2026-06-07: Added the remaining deployment handoff for this gate while
+investigating the missing daily WSJF run. The Railiance runtime projection now
+includes the daily WSJF definition alongside the disabled ops probe definition,
+schema/config support needed by the shared worker, and a working-memory PVC.
+No live `ops_inventory_probe` event exists yet, and the cluster currently lacks
+an `activity-core` namespace. Cross-repo closure tasks were posted via State
+Hub to `railiance-cluster` (`53e78702`), `inter-hub` (`f3ec4a36`),
+`the-custodian` (`7a5d4e62`), `state-hub` (`dc10704f`), and `activity-core`
+(`28d11021`). This task remains waiting on live manifest application,
+`actcore-sync`, a disabled manual probe trigger, State Hub
+`ops_inventory_probe` evidence, and an Inter-Hub activation or explicit defer
+decision.
+
+2026-06-15: Closed from railiance-cluster-owned live evidence. Railiance
+refreshed the `activity-core:railiance01-prod` runtime image from activity-core
+commit `ab17378`, synced and reconciled the current Railiance runtime bundle on
+Railiance01, reran `actcore-sync`, confirmed
+`ops-service-inventory-probes` exists with `enabled=false`, triggered the
+disabled definition manually, and verified State Hub `ops_inventory_probe`
+progress `4c82360d-33e7-455b-8ab4-33facd4a3f8e`.
+
+Evidence note: `baeeaeac-aa6d-4406-ae64-e54577f21386`.
+
+The evidence detail records Inter-Hub submission as explicitly deferred:
+`ops-hub` key custody and production Inter-Hub intake remain operator-gated,
+while the State Hub fallback evidence path passed cleanly for this handoff.
+
+## Review Verdict
+
+activity-core should provide this as a bounded probe-and-evidence capability.
+It should not provide a general operational execution engine. The first useful
+slice is safe and valuable if it remains HTTP/HTTPS-only, non-secret, disabled
+until explicitly wired, and idempotent in its evidence output.

workplans/ACTIVITY-WP-0008-weekly-coding-retro.md

@@ -0,0 +1,94 @@
+---
+id: ACTIVITY-WP-0008
+type: workplan
+title: "Weekly Coding Retrospection schedule (Saturday evenings)"
+domain: custodian
+repo: activity-core
+status: blocked
+owner: codex
+topic_slug: custodian
+created: "2026-06-07"
+updated: "2026-06-07"
+state_hub_workstream_id: "7387fc50-1f2c-471a-9d85-bb085cbd0b63"
+---
+
+# Weekly Coding Retrospection schedule (Saturday evenings)
+
+**Origin:** requested from the `helix_forge` domain. Every Saturday 19:00
+Europe/Berlin, read the previous week's coding-session analysis (published to the
+hub by helix_forge session-memory) and open **one improvement suggestion per
+relevant repo — the three most promising**.
+
+This is the same shape as the existing `weekly-sbom-staleness` activity-definition
+(cron → context resolver → per-repo task emission); only the data source is new.
+
+**Dependency:** `AGENTIC-WP-0010` (helix_forge) publishes the
+`event_type=coding_retro` read model this schedule consumes. That side computes
+and ranks (top-3 per repo, cross-flavor first, recommendations from the Pattern
+Catalog); this side schedules and routes.
+
+## `coding_retro` Context Resolver
+
+```task
+id: ACTIVITY-WP-0008-T01
+status: done
+priority: high
+state_hub_task_id: "26846304-f5f1-4edf-aba3-227c9b11c9fa"
+```
+
+Add a context resolver (`context_resolvers/`) returning the latest weekly
+coding-retro published to the hub (`event_type=coding_retro`): its
+`suggestions[]` (repo, title, recommendation, priority, score), window, and
+`generated_at`. Bind under `context.retro`. Mirror the `repo_sbom_status` resolver
+shape so rules can `for_each` over `context.retro.suggestions`.
+
+**2026-06-07:** Implemented `query: coding_retro` in the State Hub context
+resolver. It reads recent `/progress/` items, selects the latest
+`event_type=coding_retro`, normalizes `suggestions[]`, and returns an empty
+suggestion list while the upstream publisher has not produced a read model yet.
+
+## `weekly-coding-retro` Activity-Definition
+
+```task
+id: ACTIVITY-WP-0008-T02
+status: done
+priority: high
+state_hub_task_id: "09eeacb7-dc0d-4617-8398-a99a4e5a227e"
+```
+
+Add `activity-definitions/weekly-coding-retro.md`: cron `0 19 * * 6`
+Europe/Berlin, `context_source` `coding_retro`, and a rule that `for_each` over
+`context.retro.suggestions` emits one improvement task to `target_repo` with the
+suggestion title + recommendation, priority, and labels
+`[coding-retro, improvement, automated]`. Ship `enabled: false` until the resolver
++ publish are verified. A starter draft is provided at
+`activity-definitions/weekly-coding-retro.md` (proposed by helix_forge).
+
+**2026-06-07:** Updated the starter definition against the implemented resolver:
+cron Saturday 19:00 Europe/Berlin, `context_source` `coding_retro` bound to
+`context.retro`, and a rule that emits one positive-score suggestion per target
+repo with the coding-retro/improvement/automated labels. It remains
+`enabled: false` until live publish verification succeeds.
+
+## Dry-Run Verify + Enable + Docs
+
+```task
+id: ACTIVITY-WP-0008-T03
+status: wait
+priority: medium
+state_hub_task_id: "9dcbebe7-13dd-4957-9a72-858418049aef"
+```
+
+Dry-run the definition end-to-end against a published `coding_retro` read model;
+confirm one task per relevant repo (≤ 3) with correct routing and no duplicates on
+re-run. Flip `enabled: true`. Document alongside `weekly-sbom-staleness`. After
+workplan updates, run from `~/state-hub`:
+
+```bash
+make fix-consistency REPO=activity-core
+```
+
+**2026-06-07:** Added fixture-level dry-run coverage and runbook documentation.
+Live State Hub did not yet expose a published `event_type=coding_retro` progress
+item, so the real dry-run, duplicate check, and `enabled: true` flip remain
+blocked on `AGENTIC-WP-0010`.

workplans/ADHOC-2026-06-01.md

@@ -0,0 +1,225 @@
+---
+id: ADHOC-2026-06-01
+type: workplan
+title: "Ad hoc — activity-core opportunistic fixes 2026-06-01"
+domain: custodian
+repo: activity-core
+status: finished
+owner: custodian
+topic_slug: custodian
+created: "2026-06-01"
+updated: "2026-06-03"
+state_hub_workstream_id: "36162ff0-9b47-47c4-8602-56767f9b7a1c"
+---
+
+# ADHOC-2026-06-01 — activity-core opportunistic fixes
+
+Captured during the CUST-WP-0045 T06 cutover prep session. The dev worker was
+brought up and surfaced an unrelated, pre-existing bug in the state-hub
+context resolver that is independent of the daily triage canary.
+
+## Tasks
+
+### T01 - Fix repo_sbom_status resolver route and params
+
+```task
+id: ADHOC-2026-06-01-T01
+status: done
+priority: low
+state_hub_task_id: "87b56da9-e692-4350-9aff-47080414ec06"
+```
+
+`src/activity_core/context_resolvers/state_hub.py` resolves
+`query: repo_sbom_status` by calling `GET /sbom/status?repo={repo_slug}`, but
+State Hub does not expose `/sbom/status` at all. Actual SBOM routes are
+`/sbom/`, `/sbom/{repo_slug}`, `/sbom/snapshots/`, `/sbom/snapshots/{id}`,
+`/sbom/ingest/`, `/sbom/report/licences/`.
+
+Compounding bug: the only ActivityDefinition using this query is
+`activity-definitions/weekly-sbom-staleness.md`, which passes
+`params: { repos: all }`. The resolver reads `params.get("repo_slug", "")`,
+so the lookup URL collapses to `/sbom/status?repo=` regardless of the
+ActivityDefinition value.
+
+Symptom: every Monday at 09:00 Europe/Berlin (and on worker startup after a
+missed Monday tick), the `weekly-sbom-staleness` workflow runs and the
+resolver logs `HTTP/1.1 404 Not Found` for `GET /sbom/status?repo=`. The
+`_fetch_json` helper swallows the error and returns `{}`, so the workflow
+continues but the downstream rule evaluates
+`context.repos.sbom_age_days > 30` against an empty dict and never spawns
+the intended SBOM rescan tasks. The weekly SBOM staleness check has been
+silently no-op for as long as this route mismatch has existed.
+
+Fix scope:
+
+1. Decide the contract — single-repo lookup (current parameter shape suggests
+   this) versus multi-repo bulk lookup (`repos: all` suggests this).
+2. Update the resolver to call the actual State Hub route(s):
+   - single repo: `GET /sbom/{repo_slug}` (or `/sbom/{repo_slug}/status` if a
+     status-shaped projection is preferred and exists).
+   - bulk: iterate the State Hub `/repos/` list and call `/sbom/{repo_slug}`
+     per repo, returning a list bound to `context.repos`.
+3. Update `activity-definitions/weekly-sbom-staleness.md` to match: either pass
+   a real `repo_slug` per definition (multiple definitions, one per repo) or
+   keep `repos: all` and let the resolver fan out.
+4. Update the rule expression to traverse the resulting shape — currently
+   `context.repos.sbom_age_days` assumes a single object; if the resolver
+   returns a list, the rule needs `any(repo.sbom_age_days > 30 for repo in
+   context.repos)` or an equivalent per-repo evaluation.
+5. Add a resolver unit test that asserts the resolver hits a route State Hub
+   actually serves, and an integration test against a fixture State Hub
+   response so this regression cannot repeat.
+
+Out of scope for this adhoc:
+
+- Decoupling SBOM staleness rules from the state hub resolver.
+- Rewriting the SBOM ingestion pipeline or `sbom_source` policy.
+- Promoting this to a full workplan unless the multi-repo decision turns out
+  to need design discussion.
+
+Done when `weekly-sbom-staleness` runs cleanly against a live State Hub on
+Monday and either spawns SBOM rescan tasks for stale repos or leaves a clear
+"all SBOMs fresh" audit row — not a 404 log line and a silent no-op.
+
+**Completion — 2026-06-01:**
+
+Resolver now supports two modes selected by params:
+- single-repo: `params: {repo_slug: foo}` → `GET /sbom/{foo}`
+- bulk: `params: {repos: all}` → `GET /repos/`, computes per-repo age,
+  returns the worst-repo fields hoisted to the top of the result alongside
+  `stale_count`, `total_count`, `worst_*` fields, and the full per-repo list
+
+Never-scanned repos use a `99999` sentinel age so threshold rules treat them
+as very stale without forcing the rule expression to special-case `None`.
+
+`activity-definitions/weekly-sbom-staleness.md` kept its existing rule
+expression `context.repos.sbom_age_days > 30` (the resolver hoists the worst
+repo's age to that path). The definition now documents that the rule fires
+at most once per workflow run, not once per stale repo, and that the
+aspirational per-stale-repo fan-out exercised by the integration tests is
+not delivered by the current workflow.
+
+Live validation against the running State Hub on 2026-06-01:
+- single: `activity-core` → 36 days since SBOM ingest at 2026-04-26
+- bulk: 48 repos total, 46 stale (>30d); worst is `info-tech-canon`
+  (`last_sbom_at: null` → 99999d sentinel); rule expression evaluates True
+
+Tests: `uv run pytest -q` → 120 passed, 1 skipped (previously 116 passed +
+4 broken integration tests; broken-on-my-change reverted by hoisting the
+worst-repo fields to the top of `context.repos`).
+
+### T02 - Rule action context interpolation and per-iteration binding
+
+```task
+id: ADHOC-2026-06-01-T02
+status: done
+priority: low
+state_hub_task_id: "6b3a185e-cbea-454c-82fb-8b4c16cefef0"
+```
+
+Discovered while completing T01: `RunActivityWorkflow` builds each
+`TaskSpec` by lifting raw YAML fields out of the rule action without ever
+interpolating `context.*` references:
+
+```python
+# src/activity_core/workflows.py
+task_spec_dicts.append({
+    "title": action.get("task_template", rule.get("id", "")),
+    "target_repo": action.get("target_repo"),
+    ...
+})
+```
+
+So `target_repo: context.repos.repo_slug` in an ActivityDefinition rule is
+emitted to the spawn log as the literal string `"context.repos.repo_slug"`,
+not the actual stale repo slug. The aspirational per-stale-repo fan-out
+exercised by `test_pipeline_emits_one_task_for_stale_repo_only` and friends
+in `tests/test_integration_event_bridge.py` is *not* delivered by the
+workflow — those tests simulate a per-repo iteration the real workflow
+does not perform.
+
+Two pieces of work, likely related:
+
+1. **Action field interpolation.** Define and implement a safe template
+   grammar for `action.target_repo`, `action.task_template`,
+   `action.priority`, `action.labels`, etc. Reuse the rule-condition AST
+   walker (no `exec`, no comprehensions) or a constrained string
+   `{context.foo.bar}` substitution. Decide on grammar — instruction
+   prompt rendering uses `{...}` placeholders today
+   (`rules/executor.py::_render_prompt`); consistent with that is probably
+   right.
+
+2. **Per-iteration context binding.** Decide whether the workflow should
+   evaluate a rule once per element of a list-valued context field (the
+   integration-test contract), or whether the spawn-once semantics is
+   actually desired and the tests should be relaxed. If iteration is the
+   answer, the resolver shape from T01 already gives a clean `repos` list
+   to iterate over; the workflow would need an explicit `for_each:`
+   directive on the rule, or implicit iteration when `condition` references
+   a list element.
+
+This is borderline workplan-grade work (design decision + security review of
+the interpolation grammar + workflow change + test updates). Promote to a
+full workplan if anyone decides to actually do it; the adhoc T02 is just to
+make sure the gap doesn't get forgotten.
+
+Done when either: (a) rule action fields interpolate `context.*`
+expressions and a stale-repo workflow run emits a TaskSpec with the actual
+repo slug, or (b) a recorded decision explicitly defers/declines the change
+with reasoning.
+
+**Completion — 2026-06-03:**
+
+Implemented explicit rule action expansion in `activity_core.rules.actions`.
+`evaluate_rules` now returns concrete TaskSpec dictionaries directly, and
+`RunActivityWorkflow` no longer lifts raw YAML action fields itself.
+
+Action fields support two safe interpolation forms:
+- whole-field paths such as `target_repo: context.repo.repo_slug`
+- scalar placeholders such as `task_template: Run SBOM rescan for {context.repo.repo_slug}`
+
+Rules may opt into per-item binding with:
+
+```yaml
+for_each: context.repos.repos
+bind_as: repo
+condition: 'context.repo.sbom_age_days > 30'
+```
+
+`activity-definitions/weekly-sbom-staleness.md` now uses that explicit
+contract, so bulk SBOM staleness evaluation emits one task per stale repo
+instead of one task for the hoisted worst repo. Tests cover direct action
+interpolation, `for_each` binding, activity-level rule evaluation, and the
+weekly SBOM integration path.
+
+Tests: `PYTHONPATH=src .venv/bin/python -m pytest -q` -> 125 passed, 1 skipped.
+
+### T03 - Make activity-core's Temporal activity timeout env-configurable
+
+```task
+id: ADHOC-2026-06-01-T03
+status: done
+priority: low
+state_hub_task_id: "bc9c9edb-e20b-4ff9-a15d-6e3e81f9b5e1"
+```
+
+Discovered during the CUST-WP-0045 T06 canary on 2026-06-01. The daily
+triage instruction call hit `BrokenPipeError` on the llm-connect side
+because two 5-minute timeouts were racing:
+
+- `_ACTIVITY_TIMEOUT = timedelta(minutes=5)` in `workflows.py`
+- `LLM_CONNECT_TIMEOUT_SECONDS` default `300` in `llm_client.py`
+
+The 10KB curated digest + `max_depth: 2` + JSON schema enforcement pushed
+Claude past 5 minutes. Whichever timer fired first killed the httpx call,
+and the model's late response arrived to a closed socket.
+
+Fix: read `_ACTIVITY_TIMEOUT` from env `ACTIVITY_TIMEOUT_SECONDS` (default
+`900` — 15 minutes), so the Temporal activity outlives a normal slow LLM
+run. Operators are expected to also widen httpx via
+`LLM_CONNECT_TIMEOUT_SECONDS=840` (or similar) so httpx still times out
+slightly *before* Temporal, preserving the clean-error contract.
+
+The activity timeout default is now larger by design — Temporal will still
+heartbeat and Temporal-side cancellation still works; this only widens the
+upper bound for long judgment-call activities like the daily triage.

workplans/archived/260603-WP-0002-next-steps.md

@@ -1,11 +1,19 @@
 ---
 type: session-note
 created: "2026-03-28"
-status: handoff
+updated: "2026-06-03"
+status: archived
 ---
 
 # WP-0002 Handoff Note — Continue on CoulombCore
 
+## Archive note — 2026-06-03
+
+This handoff note has been reconciled and archived. Its remaining build order
+is superseded by `custodian-WP-0002-triggers-ops.md`, which is marked done, and
+by later completed workplans for the event bridge, Railiance operations, and
+production service. It is no longer an active source of next steps.
+
 ## Context
 
 Implementing custodian-WP-0002 (Triggers & Ops). Work interrupted on workstation

workplans/custodian-WP-0003-event-bridge.md

@@ -3,7 +3,7 @@ id: custodian-WP-0003
 type: workplan
 domain: custodian
 repo: activity-core
-status: superseded
+status: finished
 superseded_by:
   - custodian-WP-0003a   # phases 7–8: model, rules, registry
   - custodian-WP-0003b   # phases 9–10: parser, workflow, triggers, webhooks