✨ feat(core,daemon,webapp): issue-driven agents, pluggable runtimes with fleet observability, and an incremental transcript engine

Transcript engine performance and a steadier TUI rail
- The activity engine now parses only the bytes appended to a session
  transcript since the last read (per-adapter fold state, LRU-bounded,
  thread-safe), and a stat-signature memo answers unchanged reads for the
  cost of a stat. A daemon that pegged CPU and grew memory without bound on
  large transcript trees now idles near zero with flat RSS.
- The TUI transcript rail force-scrolls to the tail only when the viewer is
  already there, and a degraded read keeps the last good turns instead of
  flapping to "(no transcript)" — no more scroll yanks on busy sessions.

Issue-driven agents (GitHub and Gitea)
- Comment `@grove <task>` on an issue and an agent picks it up: Grove creates
  a ticket-linked workspace, and follow-up comments steer the already-running
  session instead of starting over. Pause/resume/stop/status verbs manage the
  run from the issue thread.
- One sticky status comment per issue stays continuously updated with the
  agent's state, a live todo checklist, the branch, and a deep link to the
  workspace session.
- Ships as a reusable composite action with GitHub and Gitea caller examples,
  a permission-gated and deduplicated daemon ingest endpoint, comment I/O on
  the ticket providers, and a full setup guide.

Onboarding CLI
- `grove config add-project` registers a repo with Grove from the shell;
  `grove skills install` drops a bundled fleet-orchestration skill into
  Claude Code / Codex; `grove mcp install` registers Grove as an MCP server
  through each tool's own `mcp add`; `grove config init --with-onboarding`
  runs the whole funnel non-interactively.

Agent introspection keeps pace with the tools
- Claude Code's split-call Task system (TaskCreate/TaskUpdate) is recognized
  and folded into the same todo shape TodoWrite produces, so task boards
  reconstruct correctly on every surface with zero wire changes.
- A per-adapter telemetry-env seam auto-enables native tool telemetry at
  launch.

Transcript rendering
- File edits render as always-visible inline diff cards: worktree-relative
  path with a full-path tooltip, +/− line counts, a line-number gutter, and
  neutral code text with tinted add/remove rows.
- Single-pane view widens the transcript column to use a desktop viewport;
  split view keeps its reading measure.

Runtime spine, native interception, and observability
- Launch, keep-alive, steer, and observe are decoupled from tmux behind a
  pluggable launch-backend seam; headless and Docker-container backends join
  the tmux default.
- Native interception replaces keystroke hacks: default-on hook push, a
  native permission-prompt tool, a bidirectional steering channel, and a
  per-session control surface with a webapp Controls tab.
- The sub-agent fleet is visible end to end: an agentic-loop spine, a
  per-sub-agent fleet tree in the webapp, a live token indicator, and a
  pinned todo/plan card above the composer.
- Observability groundwork: an LLM gateway proxy, an OpenTelemetry trace
  instrumentor over the loop spine, and telemetry configuration composed
  into every launch.

Author: bearlike

.gitea/workflows/issue-ops.yml

@@ -0,0 +1,40 @@
+name: Grove issue-ops (dogfood)
+
+# Grove's own issue-ops caller. `created` only, never `edited` — an edited-comment
+# trigger is a silent re-fire hole (tickets/CLAUDE.md verdict).
+on:
+  issue_comment:
+    types: [created]
+
+# Restricted-mode Gitea (>=1.26.0) 403s an undeclared `issues: write`; declare
+# both up front even though older instances only parse-and-ignore this block.
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  forward:
+    name: Forward triggered comment to Grove
+    # Fast, case-sensitive pre-filter to skip spinning up a runner on obviously
+    # unrelated comments; the action's own guard re-checks case-insensitively.
+    if: contains(github.event.comment.body, '@grove')
+    # A default docker act_runner job can't reach the daemon's host loopback —
+    # this needs the dedicated :host-schema runner (tickets/CLAUDE.md verdict).
+    runs-on: grove-issueops
+    steps:
+      - name: Require GROVE_DAEMON_URL
+        if: vars.GROVE_DAEMON_URL == ''
+        run: |
+          echo "::error::vars.GROVE_DAEMON_URL is not set on this repo — configure it in Settings > Actions > Variables"
+          exit 1
+
+      # Local composite action lives in this same repo, so a relative
+      # `uses: ./actions/issue-ops` needs the checkout first.
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Run grove-issue-ops
+        uses: ./actions/issue-ops
+        with:
+          daemon-url: ${{ vars.GROVE_DAEMON_URL }}
+          daemon-token: ${{ secrets.GROVE_DAEMON_TOKEN }}

.github/actionlint.yaml

@@ -0,0 +1,16 @@
+# actionlint config (#198). actionlint is GitHub-only, so it can't model two
+# things this repo legitimately does on Gitea: a custom self-hosted runner
+# label, and Gitea's `https://host/owner/repo@ref` absolute-URL `uses:`
+# extension (verified against docs.gitea.com — not a typo in our YAML).
+self-hosted-runner:
+  labels:
+    - grove-issueops
+
+# No `config-variables:` list — that flag turns on strict vars-checking
+# repo-wide (every workflow, not just this one), which would break existing
+# workflows' vars unrelated to issue-ops. Leave it unset (default: no check).
+
+paths:
+  docs/examples/issue-ops-gitea-caller.yml:
+    ignore:
+      - 'specifying action ".+" in invalid format'

.github/workflows/grove-issue-ops.yml

@@ -0,0 +1,53 @@
+name: Grove issue-ops (reusable)
+
+# Reusable workflow wrapping the grove-issue-ops composite action for
+# consumer repos. `uses: ./actions/issue-ops` only resolves within THIS repo's
+# own checkout, so a cross-repo caller needs the repo-qualified form
+# (`bearlike/Grove/actions/issue-ops@<ref>` — pin a released tag, not a
+# branch, once one exists).
+
+on:
+  workflow_call:
+    inputs:
+      trigger:
+        description: "Mention token that must open a comment"
+        type: string
+        required: false
+        default: "@grove"
+      allow-users:
+        description: "SECURITY-SENSITIVE: comma-separated logins trusted without repo write access"
+        type: string
+        required: false
+        default: ""
+      daemon-url:
+        description: "Base URL of the caller's Grove daemon, reachable from their self-hosted runner"
+        type: string
+        required: true
+    secrets:
+      GROVE_DAEMON_TOKEN:
+        description: "Bearer token for the caller's Grove daemon issue-ops route"
+        required: true
+
+jobs:
+  forward:
+    name: Forward triggered comment to Grove
+    # Fast, case-sensitive pre-filter so a non-command comment never spins up
+    # the (self-hosted) runner below; the composite action's own guard
+    # re-checks case-insensitively. A workflow_call job still sees the
+    # caller's triggering event via the `github` context.
+    if: contains(github.event.comment.body, inputs.trigger)
+    # Must reach the caller's daemon over their own network — a GitHub-hosted
+    # runner can't, so this needs a same-host (or same-network) self-hosted
+    # runner, mirroring the Gitea `:host` runner constraint (tickets/CLAUDE.md).
+    runs-on: [self-hosted]
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Run grove-issue-ops
+        uses: bearlike/Grove/actions/issue-ops@v1 # placeholder ref — pin once a tag ships
+        with:
+          daemon-url: ${{ inputs.daemon-url }}
+          daemon-token: ${{ secrets.GROVE_DAEMON_TOKEN }}
+          trigger: ${{ inputs.trigger }}
+          allow-users: ${{ inputs.allow-users }}

CLAUDE.md

@@ -34,6 +34,7 @@ When you own a Gitea issue end-to-end, drive it to a merged PR on this loop. Bia
 | `src/grove/core/contracts/` | wire-level Pydantic shapes that cross clients | [contracts/CLAUDE.md](src/grove/core/contracts/CLAUDE.md) |
 | `src/grove/core/agents/` | tool-agnostic agent introspection (adapters) | [agents/CLAUDE.md](src/grove/core/agents/CLAUDE.md) |
 | `src/grove/core/tickets/` | branch-aware ticket providers (Gitea/GitHub/Linear) | [tickets/CLAUDE.md](src/grove/core/tickets/CLAUDE.md) |
+| `src/grove/core/issueops/` | issue-comment events → workspace actions (command grammar + routing) | [issueops/CLAUDE.md](src/grove/core/issueops/CLAUDE.md) |
 | `src/grove/core/notifications/` | push notifications on agent-state edges (broker + channels) | [notifications/CLAUDE.md](src/grove/core/notifications/CLAUDE.md) |
 | `src/grove/daemon/` | loopback FastAPI daemon (multi-repo, SSE) | [daemon/CLAUDE.md](src/grove/daemon/CLAUDE.md) |
 | `src/grove/client/` | transport-agnostic attach (local PTY / SSH) | [client/CLAUDE.md](src/grove/client/CLAUDE.md) |
@@ -58,6 +59,7 @@ Working memory is **distributed and recursive**: every component owns a nested `
 │  ├─ src/grove/core/contracts/CLAUDE.md   the wire boundary (Pydantic shapes that cross clients)
 │  ├─ src/grove/core/agents/CLAUDE.md       tool-agnostic agent introspection (adapters)
 │  ├─ src/grove/core/tickets/CLAUDE.md      branch-aware ticket providers (Gitea/GitHub/Linear)
+│  ├─ src/grove/core/issueops/CLAUDE.md      issue-comment events → workspace actions (grammar + routing)
 │  └─ src/grove/core/notifications/CLAUDE.md  push on agent-state edges (broker + channels)
 ├─ src/grove/daemon/CLAUDE.md          loopback HTTP daemon (multi-repo, SSE)
 ├─ src/grove/client/CLAUDE.md          transport-agnostic attach (local PTY / SSH)