Briefing Follow-up — load + present agenda (MVP)

When to use

Invoke as /catalyst-dev:briefing-followup after /catalyst-dev:morning-briefing has produced today's briefing. The skill reads that briefing's decisions: block and walks the user through each open decision in turn. Phase 2 wires the real action handlers listed below; ADR-drift-specific actions ship in Phase 3 (CTL-464) and resolution write-back to the briefing markdown ships in Phase 4 (CTL-465). See [[2026-05-16-catalyst-phase-agent-architecture]] §Initiative 3 Phase 2.

Flags

| Flag | Meaning | |---|---| | --date YYYY-MM-DD | Target briefing date. Default: today (UTC). | | --file PATH | Override path resolution entirely (test/dev usage). | | --status STATUS | Decision-status filter: open (default) or all. |

Step 1: Prelude — start session, resolve date, load briefing

SCRIPT_DIR="${CLAUDE_PLUGIN_ROOT:-plugins/dev}/scripts/briefing-followup"
SESSION_SCRIPT="${CLAUDE_PLUGIN_ROOT:-plugins/dev}/scripts/catalyst-session.sh"

CATALYST_SESSION_ID=$("$SESSION_SCRIPT" start --skill "briefing-followup" \
  --ticket "" --workflow "${CATALYST_SESSION_ID:-}")
export CATALYST_SESSION_ID

# Resolve briefing path. Pass --date / --file straight through from the user.
BRIEFING_PATH=$(bash "$SCRIPT_DIR/parse-briefing.sh" path "$@")
DATE=$(basename "$BRIEFING_PATH" .md)
echo "Briefing date: $DATE"
echo "Briefing path: $BRIEFING_PATH"

# Load + validate frontmatter (exits 1 with a helpful suggestion if missing,
# exits 2 if frontmatter is malformed or absent).
if ! FRONTMATTER_JSON=$(bash "$SCRIPT_DIR/parse-briefing.sh" load "$@"); then
  "$SESSION_SCRIPT" end "$CATALYST_SESSION_ID" --status failed \
    --reason "briefing not found or malformed"
  exit 1
fi

If the briefing doesn't exist, parse-briefing.sh prints the resolved path and a suggestion to run /catalyst-dev:morning-briefing before failing. Surface that message verbatim to the user.

Step 2: Present the agenda

Render the open decisions as a numbered list with summary + type:

echo
echo "─── Agenda for $DATE ───"
bash "$SCRIPT_DIR/parse-briefing.sh" agenda "$@"
echo "───────────────────────"
echo

DECISION_COUNT=$(bash "$SCRIPT_DIR/parse-briefing.sh" decisions "$@" | jq 'length')
if [[ "$DECISION_COUNT" -eq 0 ]]; then
  echo "No open decisions in this briefing. Nothing to follow up on."
  "$SESSION_SCRIPT" end "$CATALYST_SESSION_ID" --status done \
    --reason "no open decisions"
  exit 0
fi
echo "$DECISION_COUNT open decision(s) to walk through."

Step 3: Resolve log dir + resolution recorder

Resolve the log path before the loop. Inside an orchestrator dispatch ($CATALYST_ORCHESTRATOR_DIR is set), prefer the orchestrator's run directory so the record lands next to other worker artifacts; otherwise fall back to /tmp for local runs. Phase 4 (CTL-465) of the parent plan replaces the placeholder log with a real resolutions: write-back to the briefing markdown; for now the recorder writes both a TSV log (Phase 1 contract) and a structured JSON file (Phase 2 contract that Phase 4 will consume).

if [[ -n "${CATALYST_ORCHESTRATOR_DIR:-}" ]]; then
  LOG_DIR="$CATALYST_ORCHESTRATOR_DIR"
else
  LOG_DIR="/tmp"
fi
LOG_FILE="$LOG_DIR/briefing-followup-$DATE.log"
mkdir -p "$LOG_DIR"
: > "$LOG_FILE"  # truncate any prior run from today

log_response() {
  local id="$1" action="$2" note="${3:-}"
  printf '%s\t%s\t%s\t%s\n' \
    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$id" "$action" "$note" \
    >> "$LOG_FILE"
}

# Structured resolution recorder — appends to a JSON array consumed by Phase 4.
# Call after a successful action with the action name and the action's JSON output.
record_resolution() {
  local id="$1" action="$2" result_json="${3:-{\}}"
  bash "$SCRIPT_DIR/record-resolution.sh" \
    --log-dir "$LOG_DIR" --date "$DATE" \
    --id "$id" --action "$action" --result "$result_json"
}

Step 4: Loop over decisions

For each open decision, present the details and the action set filtered by decision type. The action handlers live in sibling scripts and each emit a one-line JSON result on stdout; the skill captures that JSON and feeds it to record_resolution.

DECISIONS_JSON=$(bash "$SCRIPT_DIR/parse-briefing.sh" decisions "$@")

# Iterate over the JSON array. `jq -c .[]` emits one decision per line.
INDEX=0
TOTAL="$DECISION_COUNT"
echo "$DECISIONS_JSON" | jq -c '.[]' | while IFS= read -r dec; do
  INDEX=$((INDEX + 1))
  ID=$(echo "$dec"      | jq -r '.id')
  TYPE=$(echo "$dec"    | jq -r '.type')
  SUMMARY=$(echo "$dec" | jq -r '.summary')
  PR_URL=$(echo "$dec"  | jq -r '.pr_url // empty')
  TICKET=$(echo "$dec"  | jq -r '.ticket // empty')
  ADR=$(echo "$dec"     | jq -r '.adr // empty')
  PENDING=$(echo "$dec" | jq -r '.pending // empty')

  echo
  echo "═══ Decision $INDEX of $TOTAL ═══"
  echo "id:      $ID"
  echo "type:    $TYPE"
  echo "summary: $SUMMARY"
  [[ -n "$PR_URL"  ]] && echo "pr:      $PR_URL"
  [[ -n "$TICKET"  ]] && echo "ticket:  $TICKET"
  [[ -n "$ADR"     ]] && echo "adr:     $ADR"
  [[ -n "$PENDING" ]] && echo "pending: $PENDING"
  echo

  # A compound-engineering ADR proposal is discriminated by a non-empty
  # `pending:` field (morning-briefing emits these as type=judgment_call with a
  # `pending:` path, because the frontmatter schema's type enum has no
  # `compound_adr` value). Check it before the type switch.
  if [[ -n "$PENDING" ]]; then
    echo "Actions: [a]pply ADR proposal · [e]dit then apply · [D]efer · [r]eject · [s]kip · [q]uit"
  else
    case "$TYPE" in
      blocked_pr)
        echo "Actions: [a]pprove · [r]eject · [d]efer · [o]rchestrate · [s]kip · [q]uit"
        ;;
      adr_drift)
        echo "Actions: [u]pdate ADR · [t]icket (code drift) · [D]efer · [s]kip · [q]uit"
        ;;
      *)
        echo "Actions: [a]pprove · [r]eject · [d]efer · [c]alendar · [t]icket · [o]rchestrate · [e]mail · [s]kip · [q]uit"
        ;;
    esac
  fi
done

When this skill runs in an interactive Claude Code session, present each decision as above and use the model to interpret the user's natural-language response. Map intents to action handlers as follows:

| User intent | Handler | Captures resolution? | |---|---|---| | approve / accept / yes / ship it | log_response "$ID" approve "$NOTE" | TSV log only | | reject / no / dismiss | log_response "$ID" reject "$NOTE" | TSV log only | | defer / later / skip for today | log_response "$ID" defer "$NOTE" | TSV log only | | schedule meeting / book time / put on calendar | action-schedule.sh → record_resolution "$ID" schedule_calendar "$JSON" | TSV + JSON | | file a ticket / open Linear issue | action-ticket.sh → record_resolution "$ID" file_ticket "$JSON" | TSV + JSON | | dispatch orchestrator / kick off the work / run oneshot | action-orchestrate.sh --bg → record_resolution "$ID" dispatch_orchestrator "$JSON" | TSV + JSON | | draft email / send a note to X / message Y | action-email.sh → record_resolution "$ID" draft_email "$JSON" | TSV + JSON | | edit / update the ADR (adr_drift only) | action-adr.sh --mode update --adr-file "$ADR" → record_resolution "$ID" adr_update "$JSON" | TSV + JSON | | file code-drift ticket / fix the code (adr_drift only) | action-adr.sh --mode ticket --adr-file "$ADR" --team CTL --summary "$SUMMARY" --drift-status "$DRIFT_STATUS" → record_resolution "$ID" adr_ticket "$JSON" | TSV + JSON | | defer / note as intentional (adr_drift only) | action-adr.sh --mode defer --adr-file "$ADR" --reason "$REASON" → record_resolution "$ID" adr_defer "$JSON" | TSV + JSON | | apply / approve / accept the ADR proposal (decisions with a pending: path) | action-compound.sh --mode apply --pending "$PENDING" --ticket "$TICKET" → record_resolution "$ID" compound_apply "$JSON" | TSV + JSON | | edit / tweak then apply the proposal (pending:) | action-compound.sh --mode edit --pending "$PENDING" --ticket "$TICKET" → `record_resolution "$ID" compound_

briefing-followup

Como adicionar

Cole no README do seu repo

Skills relacionadas

understand-domain

understand-dashboard

understand-chat

dev-browser

Receba novas skills de Pesquisa e Web toda segunda