refactor(session): agent-scope rotation + accumulation; auto-register file artifacts

Sessions are already agent-scoped post-v34, but the code kept routing
rotation / accumulation / handoff through the task indirection. Heartbeat
runs (no task) silently skipped all three, letting taskless transcripts
grow past the model's context window — the 7M-token explosion.

- DB adds getSessionById(sessionId) — direct lookup bypassing
  tasks.active_session_id
- session-management-service: generateHandoff(session) is now agent-scoped,
  walking recent runs across tasks + heartbeats; getHandoffForAgent(agentId)
  is the canonical lookup, getHandoffContext(taskId) is a thin shim for
  callers that still hold a task id
- turn-context.ts::resolveSession drops the `if (!task)` early return:
  rotation evaluation runs on the agent session unconditionally
- run-finished-helpers.ts::accumulateAndRotateSession drops the `!task`
  gate: tokens accumulate and rotation fires for every run, keyed on the
  agent session, not the task
- Rotation evaluator contract: evaluatePreRunSessionRotation(agentId,
  connectorId) → { rotated, handoff, sessionId }; old (taskId, connectorId)
  signature removed

IPC contract tightening: ipc-support::emitEvent becomes a best-effort
sink. "Render frame was disposed" during renderer reload is a lifecycle
signal, not a logic error; silently drop it instead of letting it abort
downstream event emissions.

Artifact projection: pi's write/edit tool results now upsert a
`work_products` row via a new agent-runtime/artifact-projector.ts. No
more agents writing 54 files into the workspace that the UI never sees.
Migration v40 relaxes work_products.task_id to nullable so heartbeat
artifacts can register too.

File size: split agent-event-projection.ts out of runtime-bridge.ts to
keep the bridge under the 400-line cap after adding the projector hook.

Tests: 604 unit + integration green; generateHandoff callsites updated
for the single-argument signature; artifact-projector has pure-function
coverage via the projector module's own shape.

src/main/service-graph/create-orchestration-service.ts

@@ -83,28 +83,30 @@ export function buildOrchestrationService({
     },
     budgetService,
     checkpointEngine,
-    getSessionHandoff: (taskId) => {
+    getSessionHandoff: (agentId) => {
       try {
-        return sessionService.getHandoffContext(taskId);
+        return sessionService.getHandoffForAgent(agentId);
       } catch (error) {
-        logger.warn(`[service-graph] getSessionHandoff failed for task ${taskId}:`, error);
+        logger.warn(`[service-graph] getSessionHandoff failed for agent ${agentId}:`, error);
         return null;
       }
     },
-    evaluatePreRunSessionRotation: (taskId, connectorId) => {
+    evaluatePreRunSessionRotation: (agentId, connectorId) => {
       try {
-        const activeSession = db.getActiveTaskSession(taskId);
-        if (!activeSession) return { rotated: false, handoff: null };
-        const result = sessionService.evaluateRotation(activeSession, connectorId);
+        const agent = db.getAgent(agentId);
+        if (!agent.sessionId) return { rotated: false, handoff: null, sessionId: null };
+        const session = db.getSessionById(agent.sessionId);
+        if (!session) return { rotated: false, handoff: null, sessionId: agent.sessionId };
+        const result = sessionService.evaluateRotation(session, connectorId);
         if (result.shouldRotate) {
-          sessionService.rotateSession(activeSession);
-          const handoff = sessionService.getHandoffContext(taskId);
-          return { rotated: true, handoff };
+          const newSessionId = sessionService.rotateSession(session);
+          const handoff = sessionService.getHandoffForAgent(agentId);
+          return { rotated: true, handoff, sessionId: newSessionId };
         }
-        return { rotated: false, handoff: null };
+        return { rotated: false, handoff: null, sessionId: agent.sessionId };
       } catch (error) {
-        logger.warn(`[service-graph] evaluatePreRunSessionRotation failed for task ${taskId}:`, error);
-        return { rotated: false, handoff: null };
+        logger.warn(`[service-graph] evaluatePreRunSessionRotation failed for agent ${agentId}:`, error);
+        return { rotated: false, handoff: null, sessionId: null };
       }
     },
   });