Skip to content

feat(harness-ops): make the session event log run where sec-default holds classic.* #15976

Closed

Description

@kyle-sexton

Problem

With session_event_log_enabled: true, the harness-ops hooks module registers a hook on all 28
observed classic.* events and ignores session_event_log_categories
(plugins/harness-ops/hooks/register.ts:68-102). Only the script applies the category filter,
after node exec-bash.mjs and bash have started and stdin has been read
(plugins/harness-ops/hooks/session-event-log.sh:160-161). Two costs follow:

  1. On an unguarded machine, every event outside the chosen categories still starts node plus bash
    and exits at the filter. With categories permission,tool, 24 of the 28 registered events do
    only that.
  2. Where the built-in guard sec-default loads (managed settings, managed-mcp.json, or a Team or
    Enterprise /login), every registered classic.* hook is held and never runs. Claude Code
    2.1.304 and later write a line for each held hook that fires. The user sees one notice per
    fired event across all 28 events, not only the ones they asked to record.

No harness-ops check tells the user that the log is on but cannot run on this machine.
/harness-ops:setup probe 5 covers the log root's .gitignore guard, not sec-default
(plugins/harness-ops/skills/setup/SKILL.md:79-111).

Decision

Owner decision, 2026-11-13: take the minimum fix plus the category filter.

  • (a) Register only the classic.* events whose category session_event_log_categories enables.
    Map each event to its category from the generated registry.
  • (b) Where the guard holds classic.* events, cut the per-event notices where a documented route
    exists. Research (below) found no documented $ call, register argument or event that lets a
    user-installed mod detect the guard before it registers. The least-bad documented route is (a),
    which limits the notices to the events the user chose, plus a setup check warning and README
    text. No undocumented detection.
  • (c) /harness-ops:setup check warns when the log is on and the guard is seated.

Out of scope:

  • The hooks.json settings-row fallback. It would need a new ADR superseding ADR 0065
    (docs/adr/0065-move-the-harness-ops-session-event-log-into-a-mod.md:84-85).
  • The organization-managed mod route, apart from a README mention.

This body is the work order for part A. Part B (the setup warning and the guard detection) is a
sub-issue, written below the === SUB-ISSUE line, to start after A merges.

Evidence

Verified this pass, at origin/main 999cb91c1b4cf7a42d821f507db46aff3e208333 (harness-ops 9.0.0):

  • register.ts returns before any on() call unless the switch is true. Otherwise it registers
    the generated block of 28 on('classic.<Event>', record).catch(passThrough) lines
    (plugins/harness-ops/hooks/register.ts:68-102).

  • record() writes on a timer for every event but SessionEnd. SessionEnd awaits the log
    script and session-retention.sh together (plugins/harness-ops/hooks/register.ts:54-62).
    Retention is gated by the switch only, never by categories.

  • The generator writes the block from every registry entry whose producer is observe, sorted
    by name (scripts/gen-hook-event-registry.sh:192-206). --check re-derives it and diffs
    (scripts/gen-hook-event-registry.sh:254-276). Its test pins the exact 28 lines
    (scripts/gen-hook-event-registry.test.sh:31-58).

  • The registry already carries each event's category. The generator's classify_to
    (scripts/gen-hook-event-registry.sh:110-141) and the script's slog_category_to
    (plugins/harness-ops/hooks/session-log-lib.sh:475-497) hold the same table. The 28 observed
    events span 12 categories, and permission,tool covers PermissionDenied, PermissionRequest,
    PostToolBatch and PostToolUseFailure.

  • slog_category_enabled (plugins/harness-ops/hooks/session-log-lib.sh:499-509) parses the
    option this way:

    • unset or empty means every category;
    • otherwise commas become spaces and the value word-splits on space, tab and newline;
    • a match is exact and case-sensitive, so an unknown name matches nothing;
    • a value made only of separators enables nothing.
  • Guard detection exists only inside mod-posture.sh
    (plugins/harness-ops/skills/audit-mod-posture/scripts/mod-posture.sh:233-302). It reads:

    • the managed settings files and drop-ins, including prependPlugins;
    • the Windows policy registry keys;
    • claude auth status subscriptionType.

    It does not check managed-mcp.json, which is a documented guard condition. It reports a
    server-managed settings cache only as "not read". Before the guard line, it runs
    claude plugin list --json and one claude plugin validate --json per mod-shipping plugin
    (plugins/harness-ops/skills/audit-mod-posture/scripts/mod-posture.sh:113-164).

  • Probe on Claude Code 2.1.323, the CI pin, using a two-hook fixture mod in a scratch directory:

    • an on('classic.X', ...) call inside an if in register validates;
    • claude plugin validate --json lists both hooks statically: notes
      hooks: classic.Stop, classic.PostToolBatch, success: true;
    • in claude plugin test with options { cats: 'tool' }, only the PostToolBatch hook ran
      (2 pass, 0 fail).
  • Baseline counter (see Baseline): with categories permission,tool, 28 of the 32 $.classic
    keys start a process, 29 runs in all.

Reported by the source item, not reproduced here (work machine, Claude Code 2.1.316, Enterprise
/login, 2026-11-02):

  • /harness-ops:audit-mod-posture printed # guard: seated (plan enterprise) and listed all 28
    classic.* hooks.
  • The transcript showed one line per fired event, for example
    harness-ops: its classic.SessionStart hook was skipped. "cc-plugin-sec-default" runs first and sent the event on past it.
    This was seen for SessionStart, UserPromptSubmit, PostToolBatch, PostToolUseFailure,
    SubagentStop, Stop and Notification.

Research

Fetched 2026-11-13. The docs pages share sitemap lastmod 2026-11-12. The changelog's newest
section is 2.1.323.

  • mods reference, "Files" and "The
    hook function": register receives only on and the userConfig options. $ exists only
    inside a hook. So no mods API call can run before the module decides what to register.
  • mods admin:
    • "Know what happens by default": the guard loads with managed settings, managed-mcp.json, or
      a Team or Enterprise /login. Users can't turn it off.
    • "Know which hooks of a user's mod don't run": a hook on classic.<Event> never runs there.
      /plugin (v2.1.299+) shows a note naming each held hook "as the mod registered it".
    • The only routes that let the hooks run are administrator actions: install the mod as the
      organization's, or leave sec-default@builtin out of managed prependPlugins.
  • mods api, "Read all settings":
    $.settings.read({ source: 'policy' }) returns the managed settings, or {}. It is callable
    only inside a hook, after registration. It covers one of the three guard conditions. Not used.
  • mods create, validation rules: each
    on call's event name must be a string literal. A variable or a loop over names fails
    validation. A condition around a literal call is not ruled out, and the probe above shows it
    works.
  • mods troubleshoot, "Find out why
    a mod does nothing": skip lines reach the transcript only in a session that hot-reloads a plugin
    directory, and otherwise go to the debug log. The page documents no user setting that silences
    them.
  • Claude Code CHANGELOG:
    • 2.1.304: "Added a transcript line when a plugin that runs first skips one of your mod's hooks,
      naming the event and the plugin". This is the reported line. It conflicts with the
      troubleshoot page, and the report matches the changelog.
    • 2.1.299 added the /plugin note.
    • 2.1.304 "Removed the notes from claude plugin validate that predicted where a mod's hooks
      would run".
  • plugin CLI reference,
    "plugin configure": a saved value prints "Restart Claude Code to apply it", so register sees a
    changed category list at the next start.
  • managed MCP, "Deploy managed-mcp.json":
    managed-mcp.json sits in the same directory as managed-settings.json on macOS, Linux/WSL and
    Windows.
  • Guard source (read for the mechanism, not a contract): mods/sec-default/hooks/register.ts in
    anthropics/claude-code hooks classic.* with next.to(e, 'append'), which skips the user tier.

Considered and rejected: a hook-time notice. A session.start hook could call
$.settings.read({ source: 'policy' }) and log once. It would see managed settings only (not
managed-mcp.json or a Team or Enterprise login). It would not cut any held-hook notice, because
the classic.* hooks are already registered by then. And it would add a hook to every session
that has the switch on. Claude Code already names held hooks itself in the /plugin note.

Settled: no documented guard signal reaches a user mod at registration. Not settled: whether the
/plugin note lists the hooks a module registered at run time or the ones it declares statically.
Only a guarded session can show it. So this work promises fewer runtime registrations and fewer
per-event skip lines, not a shorter /plugin note.

Plan

Part A, this issue. Load the built-in plugin-authoring skill and follow
.claude/rules/mod-authoring.md before editing register.ts.

  1. Write the regression tests first (red until step 2).

    • In plugins/harness-ops/hooks/session-event-log.test.ts, add:
      • Category budget. Options { session_event_log_enabled: true, session_event_log_categories: 'permission,tool' }.
        Fire every key of $.classic and count process.run calls per event. Assert that exactly
        PermissionDenied, PermissionRequest, PostToolBatch, PostToolUseFailure and SessionEnd
        start a process, and that the total is 5.
      • SessionEnd. With categories turn, SessionEnd runs only session-retention.sh. With
        session, and with "", it runs both scripts.
        Neither of these imports anything new, so on origin/main the file loads and the
        category-budget test fails with its toEqual diff listing the 28 events.
    • In a new file, plugins/harness-ops/hooks/category-filter.test.ts, add the parse table:
      import categoryFilter from ./register.ts and assert the results in the table after this
      list. It is a pure function and needs no stubs. Keeping it out of
      session-event-log.test.ts matters: until step 2 adds the export, this file fails at import,
      and the 12 existing cases are not affected.
    • In plugins/harness-ops/hooks/session-event-log.test.sh, run the same input table against
      slog_category_enabled, so one vector pins both parsers. Today the bash tests cover only
      session,turn.
    • Rewrite EXPECTED_BLOCK in scripts/gen-hook-event-registry.test.sh:31-58 to the new block
      shape (step 2).

    Parse-table cases:

    Input Enabled categories
    undefined all
    "" all
    " " none
    "tool,permission" exactly tool and permission
    " tool , permission " exactly tool and permission
    "tool,,permission" exactly tool and permission
    "TOOL" none
    "bogus" none
    "tool\tpermission" and "tool\npermission" exactly tool and permission
    "tool\rpermission" none (\r is not a bash IFS character, so this is one word)
  2. Change the generator and the module.

    • In scripts/gen-hook-event-registry.sh, change mod_ts (scripts/gen-hook-event-registry.sh:192-206) to read name and
      category from the registry and write one line per observed event:
      if (wants('<category>')) on('classic.<Event>', record).catch(passThrough).
      SessionEnd is the exception. Write it bare, on('classic.SessionEnd', record).catch(passThrough),
      because it carries retention. Update the header comment
      (scripts/gen-hook-event-registry.sh:25-30) and the mod_ts comment
      (scripts/gen-hook-event-registry.sh:192-197), whose "takes only a hook declared at the top
      of the file" the conditional block would contradict.
    • In plugins/harness-ops/hooks/register.ts, export
      categoryFilter(value: unknown): (category: string) => boolean beside scriptEnv. It restates
      slog_category_enabled on the same string scriptEnv hands the script: undefined means
      "all", any other value goes through String(value), an empty string means "all", and
      otherwise commas become spaces and the value splits on /[ \t\n]+/ only (not \s, which
      also splits on \r). In register, after the switch check,
      const wants = categoryFilter(options.session_event_log_categories) guards the generated
      lines. In record, for SessionEnd, await next(e), plus session-event-log.sh only when
      categoryFilter(config.session_event_log_categories)('session'), plus session-retention.sh
      always. No new module-level state.
    • Replace the generated block with the generator's output. Only --fetch and --from rewrite
      register.ts, and both re-stamp every registry as_of, so apply the 28 lines by hand from
      the diff --check prints, then rerun --check until it exits 0.
    • Keep the in-script filter as the backstop.
  3. Docs. Edit plugins/harness-ops/README.md, section "The per-session hook event log"
    (plugins/harness-ops/README.md:292-344). Replace the sentence at
    plugins/harness-ops/README.md:329-331 and extend the categories paragraph at
    plugins/harness-ops/README.md:338-344. The section must say:

    • registration follows the categories, so an unlisted category starts no process, and a
      changed list applies at the next start;
    • SessionEnd is always hooked while the switch is on, for retention;
    • the guard loads with managed settings, a managed-mcp.json, or a Team or Enterprise
      /login (add managed-mcp.json to the sentence at
      plugins/harness-ops/README.md:329-331);
    • there, each registered classic.* hook is held. Claude Code reports held hooks in a
      /plugin note and, from 2.1.304, in a line per skipped event. State only these documented
      facts; do not claim the /plugin note shrinks;
    • no user setting or mod signal turns that off;
    • the log runs there only after an administrator action, linked rather than restated: install
      harness-ops as one of the organization's mods (managed enabledPlugins, a directory
      marketplace named by absolute path, the plugin listed by relative path), or leave
      sec-default@builtin out of managed prependPlugins, which removes the whole guard. Point
      at the mods admin page sections "Install your organization's mods" and "Know which hooks of
      a user's mod don't run". Otherwise leave the switch off on that machine.

    Also in that section:

    • raise the tested-version line (plugins/harness-ops/README.md:325-326) to the CLI the
      conditional block was tested on;
    • change "/harness-ops:setup reports the toggles and the guard"
      (plugins/harness-ops/README.md:343) to name the .gitignore guard, so it is not read as
      sec-default before the sub-issue lands.
  4. Option text. Edit the session_event_log_categories description in
    plugins/harness-ops/.claude-plugin/plugin.json:158-163. Add that unlisted categories start no
    process, and that SessionEnd retention runs whatever the list. Also fix the
    session_event_log_enabled description (plugins/harness-ops/.claude-plugin/plugin.json:149),
    whose "on, each starts one" becomes "on, each event in an enabled category starts one". Then
    run python3 scripts/sync-plugin-options-docs.py. Never hand-edit the README options table,
    which is generated. Update the same cost sentence in the setup skill's "Turning hook logging
    on" guidance (plugins/harness-ops/skills/setup/SKILL.md:175-178).

  5. ADR note. ADR 0065's Decision says the module "hooks classic.<Event> for each event the
    registry marks observable" while the switch is on
    (docs/adr/0065-move-the-harness-ops-session-event-log-into-a-mod.md:35). Record one
    sentence: the module hooks only the events whose category session_event_log_categories
    enables, plus SessionEnd always (for retention), citing this issue. This narrows the
    decision and supersedes nothing. Follow the repo's amendment pattern (for example
    docs/adr/0018-treat-the-plugin-as-the-encapsulation-boundary-for-skill-citation.md:3 and
    docs/adr/0018-treat-the-plugin-as-the-encapsulation-boundary-for-skill-citation.md:231):

    Leave the Decision text as it is.

  6. Release. harness-ops is in fragment mode (scripts/fragment-plugins.txt), so do not bump
    plugin.json or CHANGELOG.md. Run bash scripts/new-changelog-fragment.sh harness-ops patch
    and fill a ### Fixed body. No shared-library copy is touched, so
    scripts/sync-shared-copies.sh has nothing to do; run it with --check to confirm.

Files: plugins/harness-ops/hooks/register.ts, plugins/harness-ops/hooks/session-event-log.test.ts,
plugins/harness-ops/hooks/category-filter.test.ts (new),
plugins/harness-ops/hooks/session-event-log.test.sh, scripts/gen-hook-event-registry.sh,
scripts/gen-hook-event-registry.test.sh, plugins/harness-ops/README.md,
plugins/harness-ops/.claude-plugin/plugin.json, plugins/harness-ops/skills/setup/SKILL.md
(the cost sentence only), docs/adr/0065-move-the-harness-ops-session-event-log-into-a-mod.md,
.changes/harness-ops/<new fragment>.md.

Configurability

This is a fix, not a setting. The option session_event_log_categories already exists and is
documented to narrow the log (plugins/harness-ops/.claude-plugin/plugin.json:158-163), and
registration ignoring it is the defect. No new userConfig key. Its default, empty, keeps today's
behavior: all 28 events are hooked.

Baseline

Captured 2026-11-13 on origin/main 999cb91c1b4c, before any change. Host: Windows 11, 32 logical
CPUs, Git Bash 5.3 (cygwin), Node 24.18, Claude Code 2.1.323.

Counter (drift-immune, the binding target), with the switch on and categories permission,tool,
firing all 32 $.classic keys:

Measure Baseline Target
events that start a process 28 5
process runs in total 29 5
runs on the four in-set events 4 4
runs on SessionEnd 2 1 (retention)

Wall time is secondary, and this host is noisy. One module-style run of
node exec-bash.mjs session-event-log.sh per sample, with the log on and categories
permission,tool, on a throwaway git init directory. One warm-up per arm is discarded, then 11
interleaved rounds:

Arm median mean std min max
filtered-out event (Stop) 404.0 ms 523.5 ms 325.2 ms 265.7 ms 1257.3 ms
in-set event (PostToolBatch) 450.8 ms 471.4 ms 118.7 ms 296.7 ms 723.1 ms

Noise floor: the run-to-run spread is about the size of a whole run, so wall time cannot show a
saving here. The counter proves the saving: a filtered-out event goes from one node-plus-bash run
to none. Wall-time target: the in-set arm's median stays at or below 570 ms (baseline median plus
one std), measured on the same host class.

Rerun commands:

  • Counter: the step 1 category-budget test is the compare. Assert the started-event list first,
    then the run total. Run claude plugin test from plugins/harness-ops. To produce the "before"
    evidence, run the new test against origin/main's register.ts: copy only the new
    session-event-log.test.ts cases into a checkout of main. It fails, and its toEqual diff
    lists the 28 events that start a process. On the branch it passes, with 5 events and 5 runs.
  • Wall time: save the script below as <scratch>/time-interleaved.sh. Then run
    git init <scratch>/proj && bash <scratch>/time-interleaved.sh <checkout>/plugins/harness-ops <scratch>/proj permission,tool 11
    once on main and once on the branch.
#!/usr/bin/env bash
# time-interleaved.sh <plugin-root> <project-dir> <categories> <rounds>
set -uo pipefail
root="$1" proj="$2" cats="$3" n="${4:-11}"
one() {
  local payload t0 t1
  payload=$(printf '{"session_id":"sess-bench","transcript_path":"/t/x.jsonl","cwd":"%s","hook_event_name":"%s","tool_name":"Bash","tool_use_id":"tu_1"}' "$proj" "$1")
  t0=$EPOCHREALTIME
  printf '%s' "$payload" | (cd "$proj" && CLAUDE_PROJECT_DIR="$proj" \
    CLAUDE_PLUGIN_OPTION_SESSION_EVENT_LOG_ENABLED=true \
    CLAUDE_PLUGIN_OPTION_SESSION_EVENT_LOG_CATEGORIES="$cats" \
    node "$root/hooks/exec-bash.mjs" "$root/hooks/session-event-log.sh")
  t1=$EPOCHREALTIME
  awk -v a="$t0" -v b="$t1" 'BEGIN { printf "%.1f", (b - a) * 1000 }'
}
one Stop >/dev/null
one PostToolBatch >/dev/null
out=() in=()
for ((i = 0; i < n; i++)); do
  out+=("$(one Stop)")
  in+=("$(one PostToolBatch)")
done
stats() {
  printf '%s\n' "${@:2}" | sort -n | awk -v name="$1" '{ a[NR] = $1; s += $1; q += $1 * $1 }
    END { m = s / NR; printf "%s median_ms=%s mean_ms=%.1f std_ms=%.1f min_ms=%s max_ms=%s n=%d\n", name, a[int((NR + 1) / 2)], m, sqrt(q / NR - m * m), a[1], a[NR], NR }'
}
stats filtered_out_Stop "${out[@]}"
stats in_set_PostToolBatch "${in[@]}"

The script measures the script path only. The module change removes the filtered-out run before it
starts, so on the branch the Stop arm still times a direct invocation, and the counter is what
shows the removal.

Acceptance criteria

  • AC1: The category-budget test passes. With the switch on and categories permission,tool, exactly PermissionDenied, PermissionRequest, PostToolBatch, PostToolUseFailure and SessionEnd start a process, 5 runs in total. On origin/main the same test fails, and its diff lists the 28 events that start a process (29 runs in the baseline count).
  • AC2: categoryFilter matches slog_category_enabled on every input in the step 1 table.
  • AC3: SessionEnd is hooked whenever the switch is on. With session filtered out it runs only session-retention.sh; with session enabled or categories empty it runs both scripts. SessionEnd is the one event outside the chosen categories that still starts a process.
  • AC4: The existing "budget: with the log off (the default) no classic event starts a process" test passes unchanged, and so do the other 11 existing cases.
  • AC5: bash scripts/gen-hook-event-registry.sh --check and bash scripts/gen-hook-event-registry.test.sh exit 0, and the block in register.ts is the generator's output.
  • AC6: claude plugin validate --json plugins/harness-ops reports success: true.
  • AC7: The README section states the six points in step 3, including the organization-managed route. python3 scripts/sync-plugin-options-docs.py --check exits 0.
  • AC7b: ADR 0065 carries the dated amendment section and Status line from step 5, and the session_event_log_enabled description and the setup skill's cost sentence no longer say every event starts a process.
  • AC8: A .changes/harness-ops/ fragment exists, and bash scripts/check-changelog-fragments.sh exits 0.
  • AC9: The regression test fails on main and passes on the branch, and the PR body shows both runs.
  • AC10: Timing is no worse than baseline. The counter drops from 29 to 5 runs, and the in-set wall-time median is at or below 570 ms on the same host class. Both before and after numbers are in the PR body.
  • AC11: The performance-and-waste pass is done, with findings fixed or listed in the PR body.

Required stages for the implementer

  1. Load the built-in plugin-authoring skill and read .claude/rules/mod-authoring.md.

  2. Write the fix with the regression test first: /testing:write, then /implementation:implement.

  3. Run /toolchain:check and /toolchain:lint, and run /testing:audit on the new tests.

  4. Run a performance and waste pass:

    • compare timing against the Baseline section's numbers, using its rerun commands;
    • run /code-metrics:audit for complexity and duplication;
    • run /simplify;
    • check for repeated process launches, slow loops, repeated git calls, and unclear block or
      error messages.

    Make the in-scope fixes and list the rest in the PR body.

  5. Run /review:quality-gate in code mode. This change alters no guard's decision.

  6. Run /verification:confirm against these acceptance criteria, line by line.

  7. Open the PR with the before and after numbers in its body.

Constraints and gotchas

  • Claude Code reads each hooked event name from a string literal, so every on() stays a literal
    call. The condition wraps the call; never build event names in a loop or a variable
    (create.md validation rules).
  • claude plugin validate lists every literal on() statically, conditional or not, so its
    hooks: note still shows 28 classic. hooks. That is expected.
  • register runs once per load. A changed category list applies at the next start or at
    /reload-plugins. The module-level config is reset on each register call, so it does not
    leak across reloads.
  • A conditional on() was probed on 2.1.323 only, while the README floor is 2.1.287. CI runs the
    pinned 2.1.323. Record the tested version in the README and do not claim older builds.
  • Keep session-event-log.sh's own filter. It is the backstop for a payload that reaches the
    script some other way, and session-event-log.test.sh covers it. It only catches the module
    enabling more than bash would; the shared input table in step 1 catches the module enabling
    less.
  • slog_category_enabled word-splits the option unquoted
    (plugins/harness-ops/hooks/session-log-lib.sh:505), so a value holding * or ? would glob
    against the working directory. The TS parse does not reproduce that. Keep glob characters out
    of the shared table, and leave the bash loop as-is in this issue.
  • scripts/gen-hook-event-registry.sh --check fails while any event-log or retention row is in
    hooks.json. This change adds none.
  • Audit-telemetry rows in hooks.json (audit-event-emitter.sh) are a separate envelope. Leave
    them alone.
  • Windows: on the reporting machine every process creation leaked a kernel Token object while the
    foreground lock was armed (dotfiles#1411, perf(host): Windows kernel Token leak, one per child-creating process, amplified by hook and Bash fan-out (melo-lap-001, melo-desk-001) #4372). Fewer registrations directly cut that cost.
  • Do not probe real managed settings, and do not test the guarded path on a real machine.
    claude plugin test cannot load sec-default, so the guarded behavior is covered by the
    research above and by an owner-run session.
  • .work/ and any scratch output stay uncommitted.

Context

Runner portability (overrides the timing criteria above where they conflict)

The Baseline numbers above were measured on Windows 11 with Git Bash, where these hooks run far slower than on Linux. The issue lane (.github/workflows/work-resolve-issue.yml) runs on ubuntu-24.04 and installs no shfmt, typos or hyperfine; only the PR checks install a pinned shfmt (.github/actions/setup-pinned-shfmt). Windows seconds are context, not a pass bar.

  • Binding timing gate: counts. The process-launch or call counts the Baseline commands report are measured on origin/main and on the branch in the same run on the same host. The branch meets the count target stated above (or does not exceed main where none is stated). Counts go in the PR body.
  • Wall time, same host only. If the Baseline commands can run on the host, time origin/main and the branch in the same run (median of 5; a plain time loop is fine, hyperfine is not required). The branch median is at most main's slowest run. Seconds from a different host are never compared.
  • Missing tool. Where a test or timing needs a tool the host lacks, use the stub approach the plan gives if it has one. Otherwise do not install an unpinned tool: name the missing tool in the PR body, report the count evidence, and leave the wall-time check for a maintainer to rerun with the Baseline commands (on Windows where the symptom is Windows-only). That is not a failed stop.
  • Windows-only symptoms (command-line length, Git Bash process cost) are proved on Linux by the deterministic test the plan names (for example a stub that fails when paths arrive on argv). pr-test-platforms.yml runs the Windows suites a change selects.

Activity

  1. added
    needs-owner-decisionAwaiting a human or maintainer judgment call.
    wayfind: designWayfind decision item: design-space or domain-model decision; human in the loop.
    and removed
    needs-owner-decisionAwaiting a human or maintainer judgment call.
    wayfind: designWayfind decision item: design-space or domain-model decision; human in the loop.
    on Nov 13, 2026
  2. added
    agent-readyFully specified and briefed; eligible for autonomous pickup from the frontier.
    on Nov 13, 2026
  3. github-actions commented on Nov 13, 2026

    @github-actions
    Contributor

    Size: Medium
    Complexity: Medium
    Uncertainty: Known
    Flags: none
    Blocked by: none

    I read this as a defect: harness-ops registers hooks on all 28 classic.* events even when session_event_log_categories narrows the log. Every event outside the chosen categories still starts node and bash. Where sec-default holds those events, each fired event also produces a skip notice. The body is a complete work order for part A: the generator and register.ts change, tests, docs and ADR edits, a changelog fragment, and measurable acceptance criteria.

    Part B (the setup check warning) appears to be open already as #15993. I did not treat it as a duplicate, because it is the follow-on sub-issue. No merged pull request already fixes part A.

    Automated triage. A maintainer reviews it.

  4. melodic-automation-lanes commented on Nov 13, 2026

    @melodic-automation-lanes
    Contributor

    Not admitted to the issue lane: its body or a criterion names .github/workflows/pr-test-platforms.yml, .claude/rules/mod-authoring.md, .github/workflows/work-resolve-issue.yml, which the issue lane cannot push (patch-protected-path); a builder session takes it; its title or stated work names a charge (retention), which needs an owner decision. Admission takes the issue once each of those is met, when intake triages it again (.github/actions/resolve-config/admission-rules.json).

    Reason: cost

  5. melodic-automation-lanes commented on Nov 13, 2026

    @melodic-automation-lanes
    Contributor

    The latest triage verdict holds nothing: admission moved the issue to needs-owner-decision; its comment says why.

  6. kyle-sexton commented on Nov 16, 2026

    @kyle-sexton
    MemberAuthor

    Hub ruling, 2026-11-16, on the cost refusal (2026-11-13): no billing surface. "Retention" here is the local session event log's file retention (session-retention.sh, body lines 51-52 and 161), which runs on the owner's machine and cannot bill any account. The owner's standing definition of cost is anything that can bill them (Azure, GitHub minutes or storage, plan or seat changes), and this matches none of it, so no owner decision is needed. The other refusal stands: the issue names .github/workflows/pr-test-platforms.yml, .github/workflows/work-resolve-issue.yml and .claude/rules/mod-authoring.md, which the issue lane cannot push, so a builder session takes it. Routed to a builder session.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    agent-readyFully specified and briefed; eligible for autonomous pickup from the frontier.

    Type

    Fields

    Work status

    needs-owner-decision

    Priority

    medium

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions