runtime-session-map

qcontrol can already emit normalized runtime telemetry for file, exec, connection, and HTTP activity. That data is rich enough to describe a "session" of one wrapped process, but today it lives as low-level events. qmap can make the structural shape of that runtime behavior immediately legible: a root process in the center, with grouped rugs for Files, Child Processes, and External Hosts, and weighted flows showing what the process touched most.

This is adjacent to c21's AI session map, but the input model is different. c21 visualized semantic AI-session entities such as MCP servers and skills. This cycle visualizes reduced runtime telemetry from qcontrol.

Companion to design/c36.qcontrol-integration, which defines the reducer shape, testing strategy, and cross-project integration plan.

One runnable experiment (ExperimentsApp.vue) that:

• Loads reduced qcontrol session fixtures in qmap actor/dataflow format
• Uses entityType grouping to organize runtime entities into category rugs
• Reuses c21-style grouping controls:
  • Entity Type
  • File Access
  • Actor Type
  • Flat
• Proves that runtime sessions remain legible across at least three shapes:
  • file-heavy
  • network-heavy
  • mixed runtime
• Surfaces any qmap wrapper or visual-default changes needed for runtime-session maps

• dev/experiments/c22.runtime-session-map/ExperimentsApp.vue — runnable experiment
• dev/experiments/c22.runtime-session-map/shared/ — reduced session fixtures and any reducer-facing helpers used only by the experiment
• cycles/c22.runtime-session-map/ — cycle metadata

Optional if needed:

• src/components/QMapRuntimeSession.vue — dedicated wrapper if QMapAgentSession proves too AI-session-specific

• dev/experiments/c22.runtime-session-map/ExperimentsApp.vue
  • Runtime-session experiment with grouping mode controls and fixture switching
• Reduced session fixtures
  • At least:
    • file-heavy
    • network-heavy
    • mixed-runtime
• Cycle metadata
  • initial-prompt.md
  • CYCLE.md

Optional deliverable:

• src/components/QMapRuntimeSession.vue
  • Wrapper component for runtime-session maps if a dedicated surface feels cleaner than extending QMapAgentSession

Completed.

• Built dev/experiments/c22.runtime-session-map/ExperimentsApp.vue as a runnable runtime-session experiment with the same interaction pattern as c21: Entity Type, File Access, Actor Type, and Flat.
• Added three reduced reducer-driven fixtures in dev/experiments/c22.runtime-session-map/shared/runtimeSessions.js: file-heavy, network-heavy, and mixed runtime.
• Added a small live adapter layer via dev/experiments/c22.runtime-session-map/bridge/runtimeSessionBridge.mjs plus shared/liveSessionSource.js so the experiment can poll reduced qcontrol sessions without replaying raw events in-browser.
• Promoted runtime-specific visual tuning into a dedicated wrapper, src/components/QMapRuntimeSession.vue, with RUNTIME_SESSION_DEFAULTS in src/components/QMapRuntimeSessionDefaults.js.

Key findings:

• Existing qmap grouping primitives were enough; no scene-level hacks were needed.
• A dedicated runtime wrapper was worth adding even though QMapAgentSession was close. Runtime maps benefit from different defaults and a clearer semantic entry point than the AI-session wrapper.
• The root actor should group as Root Process for entityType mode, while still keeping its mesh identity via actor type (agent or app). That makes the rugs match runtime concepts instead of AI-session concepts.
• File-dense runtime maps benefit from slightly smaller actor/rug labels, tighter rug padding, and a visible low-opacity base line beneath animated arrows.

Suggested defaults for file-dense runtime maps:

• appearance.actorLabelScale: 0.9
• appearance.rugLabelScale: 0.9
• appearance.rugPadding: 0.8
• dataflow.showLine: true
• dataflow.lineOpacity: 0.72
• slightly softer arrow and pulse opacity than the AI-session defaults

Open follow-up:

• Extremely file-heavy real sessions will eventually need reducer-side summarization or trimming, especially for repeated accesses inside the same directory tree. The current reduced model is good for validation and medium-density sessions, but not the final answer for very large runs.

This cycle should not read raw qcontrol events directly in the browser.

It should consume reduced session objects shaped roughly like:

{
  sessionId: 'pid:1234:2026-04-15T19:09:58Z',
  actors: [
    { id, type, label, tags }
  ],
  dataflows: [
    { id, origin, destination, volume, protocol }
  ],
  stats: {
    eventCount,
    actorCount,
    dataflowCount,
  },
  meta: {
    startedAt,
    endedAt,
  },
}

Initial actor categories:

• Root process
• Child process
• File
• External host

Initial qmap actor types:

• agent or app for the root process
• app for child processes
• file for files
• external-host for external hosts

The map should feel immediately readable at a glance:

• one dominant root actor
• obvious category rugs
• readable fan-out to files and hosts
• grouped file access patterns when File Access mode is enabled

This cycle should tune for runtime-session reality, which is likely denser and more starburst-shaped than c21.

Likely areas to tune:

• rug padding
• actor label scale
• handling of long file and host labels
• readability of file-heavy rugs

1. Can reduced runtime sessions be rendered legibly with existing qmap primitives and grouping?
2. Is QMapAgentSession good enough as-is, or do we want a dedicated QMapRuntimeSession wrapper?
3. Do runtime-session fixtures need different visual defaults than c21's AI-session defaults?
4. At what point does a file-heavy session need reducer-side trimming or summarization to stay useful?

• A reduced qcontrol session fixture renders cleanly in qmap without custom scene hacks
• Entity Type and File Access modes both produce readable layouts
• The root process remains visually dominant and understandable
• Mixed sessions clearly show relationships between root process, files, child processes, and external hosts
• Any needed wrapper changes are identified and kept narrow in scope

• Start with one hand-authored reduced fixture before wiring in real captured sessions
• Keep the reducer outside qmap for now; this cycle is about validating the visualization shape
• Prefer standard qmap actors and dataflows over introducing a new live-event abstraction
• Treat event replay as out of scope for this cycle