@cxi-lmai/ci-agent-platform 3.2.1 → 3.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cxi-lmai/ci-agent-platform",
-  "version": "3.2.1",
+  "version": "3.2.3",
   "description": "Autonomous dev pipeline on plain GitLab CI or GitHub Actions, driven by Claude Code. A labeled issue goes in, an open merge request comes out.",
   "keywords": [
     "claude",

package/payload/ci-templates/claude-pipeline.gitlab-ci.yml

@@ -86,9 +86,12 @@ variables:
   # GitLab's own CI_JOB_TIMEOUT minus the time already spent minus the reserve
   # below, which leaves room for the post-agent steps. An overrun then takes
   # the normal degraded path (failure-notice comment + metrics) instead of
-  # dying silently. Set PIPE_AGENT_MAX_TIME (e.g. "20m") to override the
-  # derivation for every job; GitHub Actions exposes no job-timeout variable,
-  # so there the flag is omitted and timeout-minutes stays the only bound.
+  # dying silently. This parent deadline bounds the complete omp session.
+  # Each invocation also supplies a CI-only omp config overlay: task execution
+  # is blocking (no parent polling), each child is capped at 15 minutes and 60
+  # requests, and no interactive project setting is changed. Set
+  # PIPE_AGENT_MAX_TIME (e.g. "20m") to override the parent derivation for
+  # every job.
   PIPE_AGENT_TIME_RESERVE: "180"        # seconds of the job budget kept for the post-agent steps
 
   # --- Build / verify --------------------------------------------------------

package/payload/ci-templates/scripts/lib/pipeline-common.sh

@@ -441,6 +441,24 @@ pipe_agent_max_time() {
   printf '%s' "$left"
 }
 
+pipe_omp_ci_config() {
+  # Omp's interactive defaults run tasks asynchronously and leave their
+  # runtime unbounded. CI skills consume task results synchronously, so an
+  # async reviewer makes the parent poll through repeated model turns and an
+  # unbounded child can consume the whole parent/job deadline. Keep these
+  # semantics scoped to this invocation: --config overlays the user's normal
+  # project/profile settings without modifying either.
+  local config="$PIPE_CONTEXT_DIR/omp-ci-config.yml"
+  cat > "$config" <<'YAML'
+async:
+  enabled: false
+task:
+  maxRuntimeMs: 900000
+  softRequestBudget: 60
+YAML
+  printf '%s' "$config"
+}
+
 pipe_run_omp() {
   # $1 = agent label for metrics, $2 = skill invocation (e.g. "/review-mr"),
   # $3 = allowed tools in Claude Code naming (optional, translated
@@ -452,6 +470,7 @@ pipe_run_omp() {
   # real exit code in PIPE_AGENT_RC, which pipe_require_agent_ran checks.
   local label="$1" skill="$2" tools="${3:-Agent,Read,Write,Edit,Glob,Grep,Bash}" model="${4:-}"
   local omp_tools; omp_tools=$(pipe_translate_tools_to_omp "$tools")
+  local omp_config; omp_config=$(pipe_omp_ci_config)
   # Bound the run below the job's own hard kill (see pipe_agent_max_time).
   local max_time; max_time=$(pipe_agent_max_time)
   local -a max_time_args=()
@@ -486,14 +505,15 @@ pipe_run_omp() {
       printf 'cd %q\n' "$PWD"
       printf 'source %q\n' "$SCRIPT_LIB_DIR/usage-capture-omp.sh"
       printf 'export PIPE_CAPTURE_MODEL=%q\n' "$model"
-      # The %s after `--` is the optional " --max-time <d>" fragment, already
-      # shell-quoted; it collapses to nothing when no deadline was derived.
+      # The %s after the config is the optional " --max-time <d>" fragment,
+      # already shell-quoted; it collapses to nothing when no parent deadline
+      # was derived.
       if [ -n "$model" ]; then
-        printf 'capture_omp %q --%s --yolo --no-session --no-title --model %q --tools %q -p %q < %q\n' \
-          "$label" "$max_time_txt" "$model" "$omp_tools" "$skill" "$stdin_file"
+        printf 'capture_omp %q -- --config %q%s --yolo --no-session --no-title --model %q --tools %q -p %q < %q\n' \
+          "$label" "$omp_config" "$max_time_txt" "$model" "$omp_tools" "$skill" "$stdin_file"
       else
-        printf 'capture_omp %q --%s --yolo --no-session --no-title --tools %q -p %q < %q\n' \
-          "$label" "$max_time_txt" "$omp_tools" "$skill" "$stdin_file"
+        printf 'capture_omp %q -- --config %q%s --yolo --no-session --no-title --tools %q -p %q < %q\n' \
+          "$label" "$omp_config" "$max_time_txt" "$omp_tools" "$skill" "$stdin_file"
       fi
     } > "$runner"
     chmod +x "$runner"
@@ -506,9 +526,9 @@ pipe_run_omp() {
       pipe_scrub_agent_secrets
       export PIPE_CAPTURE_MODEL="$model"
       if [ -n "$model" ]; then
-        capture_omp "$label" -- "${max_time_args[@]}" --yolo --no-session --no-title --model "$model" --tools "$omp_tools" -p "$skill" < "$stdin_file"
+        capture_omp "$label" -- --config "$omp_config" "${max_time_args[@]}" --yolo --no-session --no-title --model "$model" --tools "$omp_tools" -p "$skill" < "$stdin_file"
       else
-        capture_omp "$label" -- "${max_time_args[@]}" --yolo --no-session --no-title --tools "$omp_tools" -p "$skill" < "$stdin_file"
+        capture_omp "$label" -- --config "$omp_config" "${max_time_args[@]}" --yolo --no-session --no-title --tools "$omp_tools" -p "$skill" < "$stdin_file"
       fi
     ) || PIPE_AGENT_RC=$?
   fi

package/payload/ci-templates/scripts/lib/usage-capture-omp.sh

@@ -1,18 +1,37 @@
 # shellcheck shell=bash
 # Source-only library. Wraps an `omp --mode json` invocation, sums usage/cost
-# from the agent_end event's message transcript, writes a metrics record, and
-# surfaces the assistant text on stdout — the omp equivalent of
+# across the whole spawn tree the invocation paid for, writes a metrics record,
+# and surfaces the assistant text on stdout — the omp equivalent of
 # usage-capture.sh's capture_claude. Same function contract, same metrics
-# record shape (bar the harness-specific exit-code key), different event
-# parsing because omp's schema differs from Claude's stream-json.
+# record shape (bar the harness-specific exit-code and completeness keys),
+# different event parsing because omp's schema differs from Claude's
+# stream-json.
 #
-# Schema verified live against a real omp install (18.0.6): the final
-# "agent_end" line carries {"type":"agent_end","messages":[...],
+# Schema verified against omp 18.1.21 (minimum supported; the nested
+# `extractedToolData.task` carrier below does not exist in older lines): the
+# final "agent_end" line carries {"type":"agent_end","messages":[...],
 # "isTerminal":true}. Each assistant message in `messages[]` carries its own
 # `usage` object (per-message, not session-cumulative) and top-level
 # `model`/`provider`/`duration` fields. See
 # docs/superpowers/specs/2026-08-26-omp-openrouter-harness-design.md section 3
-# for the full verification record.
+# for the original verification record and docs/metrics.md for the aggregation
+# semantics.
+#
+# Subagents run as child sessions, so their model calls are never parent
+# assistant messages. omp exposes them one level at a time instead:
+#
+#   - a blocking `task` call's tool result carries `details.usage`, the merge
+#     of `details.results[].usage`, each of which counts only that child's own
+#     assistant messages;
+#   - that child's own `task` calls arrive under
+#     `details.results[].extractedToolData.task[]` as the same shape again
+#     (omp registers a subprocess handler for the tool), so the tree recurses
+#     with every level counted exactly once;
+#   - an async spawn exposes no usage at all: the delivery message carries
+#     jobs, not tokens. Such children are counted as unmeasured and the record
+#     marks itself incomplete rather than passing a parent-only figure off as
+#     the total. The CI config overlay in pipeline-common.sh keeps task
+#     execution blocking precisely so this stays the exceptional case.
 #
 # Usage:   capture_omp <agent_name> -- <args to pass to `omp`...>
 # Stdin:   forwarded to `omp` stdin
@@ -21,6 +40,62 @@
 
 set -u
 
+# Aggregates one `agent_end` object into a tab-separated row:
+# input, output, cacheWrite, cacheRead, cost, parent duration, subagent cost,
+# measured subagents, unmeasured subagents, model. The model is deliberately
+# last: it is the one field that can be empty (a run killed before its first
+# assistant turn), and tab is an IFS *whitespace* character, so `read` would
+# collapse an empty leading column and shift every number one place left.
+# Kept to jq 1.6 features (Debian stable ships 1.6; see metrics-snapshot.sh),
+# and assigned from a plain quoted string rather than a `cat` heredoc: sourcing
+# this library must not need a single external binary, because callers run it
+# with a deliberately minimal PATH.
+_OMP_USAGE_JQ='
+def usum(f): map(f // 0) | add // 0;
+# One `task` tool result, recursing into the nested calls its children made.
+def level:
+  ([.results[]? | select(.usage != null) | .usage]) as $own
+  | (if ($own | length) > 0 then $own
+     elif (.usage != null) then [.usage]
+     else [] end) as $usage
+  | (if ($own | length) > 0 then ($own | length)
+     elif (.usage != null) then 1
+     else 0 end) as $measured
+  # Count every agent the call spawned, measured or not. An async spawn
+  # settles with no result row at all, so the progress list is the only place
+  # it appears — including when it has a measured sibling, which must not mask
+  # it. A sync child that failed before its first request has a row but no
+  # usage, and is counted by the same subtraction.
+  | ([.results[]?] | length) as $result_rows
+  | ([.progress[]?] | length) as $progress_rows
+  | (if $progress_rows > $result_rows then $progress_rows else $result_rows end) as $spawned
+  | (if $spawned > $measured then ($spawned - $measured) else 0 end) as $gaps
+  | ([.results[]? | (.extractedToolData.task // [])[]? | level]) as $nested
+  | {
+      input:      (($usage | usum(.input))      + ($nested | usum(.input))),
+      output:     (($usage | usum(.output))     + ($nested | usum(.output))),
+      cacheWrite: (($usage | usum(.cacheWrite)) + ($nested | usum(.cacheWrite))),
+      cacheRead:  (($usage | usum(.cacheRead))  + ($nested | usum(.cacheRead))),
+      cost:       (($usage | usum(.cost.total)) + ($nested | usum(.cost))),
+      measured:   ($measured    + ($nested | usum(.measured))),
+      unmeasured: ($gaps + ($nested | usum(.unmeasured)))
+    };
+([.messages[]? | select(.role == "assistant")]) as $parent
+| ([.messages[]? | select(.role == "toolResult" and .toolName == "task") | .details | level]) as $subs
+| [
+    (($parent | usum(.usage.input))      + ($subs | usum(.input))),
+    (($parent | usum(.usage.output))     + ($subs | usum(.output))),
+    (($parent | usum(.usage.cacheWrite)) + ($subs | usum(.cacheWrite))),
+    (($parent | usum(.usage.cacheRead))  + ($subs | usum(.cacheRead))),
+    (($parent | usum(.usage.cost.total)) + ($subs | usum(.cost))),
+    ($parent | usum(.duration)),
+    ($subs | usum(.cost)),
+    ($subs | usum(.measured)),
+    ($subs | usum(.unmeasured)),
+    ([$parent[] | ((.provider // "") + "/" + (.model // ""))] | last // "")
+  ] | @tsv
+'
+
 capture_omp() {
   local agent="$1"; shift
   [ "${1:-}" = "--" ] && shift
@@ -51,23 +126,32 @@ capture_omp() {
 
   # Extract the final agent_end event (last line that begins with
   # {"type":"agent_end"). Its usage is per-message (one API call each), not
-  # pre-aggregated like Claude's single "result" event, so sum it ourselves.
+  # pre-aggregated like Claude's single "result" event, and subagent usage sits
+  # in the `task` tool results, so aggregate the tree ourselves
+  # (see _OMP_USAGE_JQ above).
   local result_line
   result_line=$(grep '^{"type":"agent_end"' "$stream_file" | tail -1 || true)
 
-  local model input output cache_c cache_r cost duration
-  if [ -n "$result_line" ]; then
-    model=$(echo "$result_line" | jq -r '[.messages[]? | select(.role=="assistant") | ((.provider // "") + "/" + (.model // ""))] | last // ""')
-    input=$(echo "$result_line" | jq '[.messages[]? | select(.role=="assistant") | .usage.input // 0] | add // 0')
-    output=$(echo "$result_line" | jq '[.messages[]? | select(.role=="assistant") | .usage.output // 0] | add // 0')
-    cache_c=$(echo "$result_line" | jq '[.messages[]? | select(.role=="assistant") | .usage.cacheWrite // 0] | add // 0')
-    cache_r=$(echo "$result_line" | jq '[.messages[]? | select(.role=="assistant") | .usage.cacheRead // 0] | add // 0')
-    cost=$(echo "$result_line" | jq '[.messages[]? | select(.role=="assistant") | .usage.cost.total // 0] | add // 0')
-    duration=$(echo "$result_line" | jq '[.messages[]? | select(.role=="assistant") | .duration // 0] | add // 0')
+  local model input output cache_c cache_r cost duration sub_cost measured unmeasured
+  local row=""
+  [ -n "$result_line" ] && row=$(echo "$result_line" | jq -r "$_OMP_USAGE_JQ" 2>/dev/null || true)
+  if [ -n "$row" ]; then
+    IFS=$'\t' read -r input output cache_c cache_r cost duration sub_cost measured unmeasured model \
+      <<< "$row"
   else
+    # No parsable agent_end (crash, killed run): the parent's own wall time is
+    # the only thing known, and nothing can be claimed about subagents.
     model=""; input=0; output=0; cache_c=0; cache_r=0; cost=0; duration=$wall_ms
+    sub_cost=0; measured=0; unmeasured=0
   fi
   [ -n "${PIPE_CAPTURE_MODEL:-}" ] && [ -z "$model" ] && model="$PIPE_CAPTURE_MODEL"
+  # Partial the moment any spawned agent's usage was not exposed: the totals
+  # above then cover less than the OpenRouter account was charged for. A run
+  # with no parsable agent_end is the extreme case — not even the parent's own
+  # tokens are known — so its zeros must not read as a settled bill either.
+  local complete=true
+  [ -z "$row" ] && complete=false
+  [ "$unmeasured" -gt 0 ] && complete=false
 
   # Recover the user-facing text (concatenate all assistant text blocks) so
   # downstream consumers that read `omp -p`'s stdout still work.
@@ -75,10 +159,11 @@ capture_omp() {
     | jq -r 'select(.message.role=="assistant") | .message.content[]? | select(.type=="text") | .text' \
     || true
 
-  # Write metrics record. Same field names as capture_claude's record; only
-  # the harness-specific exit-code key differs (omp_exit_code vs
-  # claude_exit_code), by the same convention the two capture_* files
-  # already use for their own harness-labelled fields.
+  # Write metrics record. Same field names as capture_claude's record; the
+  # harness-specific exit-code key differs (omp_exit_code vs
+  # claude_exit_code), by the same convention the two capture_* files already
+  # use for their own harness-labelled fields, and the usage_* /subagent_*
+  # keys describe a scope Claude Code's single `result` event does not have.
   local record_stamp record_file
   record_stamp=$(date +%s%N)
   record_file="$metrics_dir/${job_name}-${job_id}-${record_stamp}.json"
@@ -100,6 +185,10 @@ capture_omp() {
     --argjson duration "$duration" \
     --argjson wall_ms "$wall_ms" \
     --argjson exit_code "$exit_code" \
+    --argjson sub_cost "$sub_cost" \
+    --argjson measured "$measured" \
+    --argjson unmeasured "$unmeasured" \
+    --argjson complete "$complete" \
     '{
       ts: $ts, agent: $agent, event: $event, model: $model,
       pipeline_id: $pipeline_id, job_id: $job_id, job_name: $job_name,
@@ -107,7 +196,10 @@ capture_omp() {
       input_tokens: $input, output_tokens: $output,
       cache_creation_tokens: $cache_c, cache_read_tokens: $cache_r,
       total_cost_usd: $cost, duration_ms: $duration, wall_ms: $wall_ms,
-      omp_exit_code: $exit_code
+      omp_exit_code: $exit_code,
+      usage_scope: "tree", usage_complete: $complete,
+      subagents_measured: $measured, subagents_unmeasured: $unmeasured,
+      subagent_cost_usd: $sub_cost
     }' > "$record_file"
 
   # If the agent failed, forward stderr so debugging still works, and keep a