pmx-canvas 0.8.2 → 0.9.1

package/src/client/state/session-store.ts

@@ -3,9 +3,14 @@ import { showToast } from './attention-bridge';
 import { computed, signal } from '@preact/signals';
 import type { AxApprovalStatus, AxEventKind, AxWorkItemStatus } from '../../shared/ax-kinds.js';
 import { HUMAN_STARTED_SESSION_LABEL } from '../../shared/agent-presence.js';
-import { axSurfaceState } from './canvas-store';
+import { axSurfaceState, nodes } from './canvas-store';
 import { requestBestEffort, requestJson, requestOk } from './intent-bridge';
-import { agentActivity } from './presence-store';
+import { agentActivity, agentPresences } from './presence-store';
+import { activeBoardId } from './boards-store';
+import { agentSessionsEnabled } from './workspace-settings';
+
+/** Explicit panel expansion, shared by the panel handle and the agent popover. */
+export const sessionPanelOpened = signal(false);
 
 // Structural views of the AX wire shapes (the client never imports server
 // modules; the status/kind unions come from shared/). Only the fields the
@@ -358,6 +363,7 @@ export async function sendSteering(message: string, target?: string | null): Pro
 
 /** Attach a human-started session; the agent's writes are attributed to it. */
 export async function startSession(): Promise<boolean> {
+  if (!agentSessionsEnabled.value) return false;
   const result = await requestOk('startSession', '/api/canvas/ax/presence', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -381,6 +387,8 @@ export interface SessionReceipt {
   labels: string[];
   /** Endings folded into this card (see applySessionReceipt). */
   sessions: number;
+  /** When the session attached (the receipt's "This session · start–end"); null if unknown. */
+  startedAt: string | null;
   endedAt: string;
   /** Why it ended — the receipt should answer this, not leave the human asking. */
   endedBy?: 'human' | 'agent' | 'idle-timeout';
@@ -390,7 +398,7 @@ export interface SessionReceipt {
   counts: { items: number; done: number; cancelled: number; rejected: number; held: number };
   /** The pre-session snapshot; null when the board was empty at attach, or on a
    * merged receipt (each session's snapshot is in History). */
-  snapshot: { id: string; name: string } | null;
+  snapshot: { id: string; name: string; boardId: string | null } | null;
   /** What the session did with context (docs/design/AgentContext.dc.html receipt). */
   context: SessionContextActivity;
 }
@@ -398,9 +406,19 @@ export interface SessionReceipt {
 export interface ReceiptNode {
   id: string;
   title: string;
+  /** The board where this touch was recorded, for reopening a change's card. */
+  boardId?: string;
   reason?: string;
+  /** Edited cards: what the edit did ("rewrote the second paragraph"). */
+  change?: string;
+  /** Edited cards: the text before and at the session's end, cut around the first difference. */
+  before?: string;
+  after?: string;
 }
 
+/** Card ids are local to a board; receipts can remain open across board switches. */
+export const receiptNodeKey = (node: ReceiptNode): string => JSON.stringify([node.boardId, node.id]);
+
 export interface SessionContextActivity {
   read: ReceiptNode[];
   pinned: ReceiptNode[];
@@ -416,7 +434,15 @@ function receiptNodes(value: unknown): ReceiptNode[] {
     const record = entry as Record<string, unknown>;
     if (typeof record.id !== 'string' || typeof record.title !== 'string') return [];
     return [
-      { id: record.id, title: record.title, ...(typeof record.reason === 'string' ? { reason: record.reason } : {}) },
+      {
+        id: record.id,
+        title: record.title,
+        ...(typeof record.boardId === 'string' ? { boardId: record.boardId } : {}),
+        ...(typeof record.reason === 'string' ? { reason: record.reason } : {}),
+        ...(typeof record.change === 'string' ? { change: record.change } : {}),
+        ...(typeof record.before === 'string' ? { before: record.before } : {}),
+        ...(typeof record.after === 'string' ? { after: record.after } : {}),
+      },
     ];
   });
 }
@@ -425,22 +451,74 @@ function receiptNodes(value: unknown): ReceiptNode[] {
  * The agent-activity lens: while on, nodes the last session did not touch
  * (read, pin, create, edit) are dimmed. Null when off.
  */
-export const activityLensNodeIds = signal<Set<string> | null>(null);
+/**
+ * The activity lens ("Dim untouched nodes"): off, one live session's touches
+ * (the chip that was pressed), or the receipt's. A live lens hands over to the
+ * receipt when that session ends, and switches off if its ending has none.
+ */
+export type ActivityLens = { kind: 'live'; sessionId: string } | { kind: 'receipt' } | null;
+export const activityLens = signal<ActivityLens>(null);
+
+const touchedIds = (lists: Array<Array<{ id: string } | string>>): Set<string> =>
+  new Set(lists.flat().map((entry) => (typeof entry === 'string' ? entry : entry.id)));
+
+export const activityLensNodeIds = computed<Set<string> | null>(() => {
+  if (!agentSessionsEnabled.value) return null;
+  const lens = activityLens.value;
+  if (lens?.kind === 'live') {
+    const touches = agentPresences.value.find(
+      (presence) => presence.attached && presence.sessionId === lens.sessionId,
+    )?.session;
+    return touches ? touchedIds([touches.read, touches.pinned, touches.created, touches.edited]) : null;
+  }
+  const context = lens?.kind === 'receipt' ? sessionReceipt.value?.context : undefined;
+  return context
+    ? touchedIds(
+        [context.read, context.pinned, context.created, context.edited].map((list) =>
+          list.filter((node) => !node.boardId || node.boardId === activeBoardId.value),
+        ),
+      )
+    : null;
+});
+
+/** Cards an agent edited in a live session or in the receipt's session: they carry the violet bar. */
+export const sessionEditedIds = computed<Set<string>>(
+  () =>
+    new Set([
+      ...agentPresences.value.flatMap((presence) => (presence.attached ? (presence.session?.edited ?? []) : [])),
+      ...(sessionReceipt.value?.context.edited
+        .filter((node) => !node.boardId || node.boardId === activeBoardId.value)
+        .map((node) => node.id) ?? []),
+    ]),
+);
 
-export function setActivityLens(on: boolean): void {
-  const context = sessionReceipt.value?.context;
-  activityLensNodeIds.value =
-    on && context
-      ? new Set([...context.read, ...context.pinned, ...context.created, ...context.edited].map((node) => node.id))
-      : null;
+/** Turn the lens on for a live session (from its chip) or the receipt, or off. */
+export function setActivityLens(on: boolean, live?: { sessionId: string }): void {
+  activityLens.value = on ? (live ? { kind: 'live', ...live } : { kind: 'receipt' }) : null;
 }
 
 /** The last ended session's receipt (design item 2); client-side, cleared on dismiss. */
 export const sessionReceipt = signal<SessionReceipt | null>(null);
 
+/** A card both sessions edited: the first Before, the last After, both changes. */
+function mergeEdits(open: ReceiptNode[], next: ReceiptNode[]): ReceiptNode[] {
+  const later = new Map(next.map((node) => [receiptNodeKey(node), node]));
+  const merged = open.map((node) => {
+    const again = later.get(receiptNodeKey(node));
+    if (!again) return node;
+    later.delete(receiptNodeKey(node));
+    return {
+      ...again,
+      change: [node.change, again.change].filter(Boolean).join('; then '),
+      before: node.before ?? again.before,
+    };
+  });
+  return [...merged, ...later.values()];
+}
+
 function unionNodes(a: ReceiptNode[], b: ReceiptNode[]): ReceiptNode[] {
-  const seen = new Set(a.map((node) => node.id));
-  return [...a, ...b.filter((node) => !seen.has(node.id))];
+  const seen = new Set(a.map(receiptNodeKey));
+  return [...a, ...b.filter((node) => !seen.has(receiptNodeKey(node)))];
 }
 
 /**
@@ -452,6 +530,7 @@ function mergeReceipts(open: SessionReceipt, next: SessionReceipt): SessionRecei
   return {
     labels: [...new Set([...open.labels, ...next.labels])],
     sessions: open.sessions + 1,
+    startedAt: open.startedAt && next.startedAt && next.startedAt < open.startedAt ? next.startedAt : open.startedAt,
     endedAt: next.endedAt,
     endedBy: open.endedBy === next.endedBy ? next.endedBy : undefined,
     // Board-wide counts: the latest frame is the current board.
@@ -461,7 +540,7 @@ function mergeReceipts(open: SessionReceipt, next: SessionReceipt): SessionRecei
       read: unionNodes(open.context.read, next.context.read),
       pinned: unionNodes(open.context.pinned, next.context.pinned),
       created: unionNodes(open.context.created, next.context.created),
-      edited: unionNodes(open.context.edited, next.context.edited),
+      edited: mergeEdits(open.context.edited, next.context.edited),
       changedSinceRead: unionNodes(open.context.changedSinceRead, next.context.changedSinceRead),
     },
   };
@@ -479,10 +558,17 @@ export function applySessionReceipt(data: Record<string, unknown>): void {
   const snapshot = data.snapshot as SessionReceipt['snapshot'] | undefined;
   const context = data.context as Record<string, unknown> | undefined;
   if (typeof data.label !== 'string' || typeof data.endedAt !== 'string') return;
-  if (data.unchanged === true || typeof data.parentAgentId === 'string') return;
+  const lens = activityLens.value;
+  const endsLiveLens = lens?.kind === 'live' && lens.sessionId === data.writer;
+  if (data.unchanged === true || typeof data.parentAgentId === 'string') {
+    // The session the lens followed ended with nothing to show: the lens goes off.
+    if (endsLiveLens) activityLens.value = null;
+    return;
+  }
   const next: SessionReceipt = {
     labels: [data.label],
     sessions: 1,
+    startedAt: typeof data.startedAt === 'string' ? data.startedAt : null,
     endedAt: data.endedAt,
     endedBy:
       data.endedBy === 'human' || data.endedBy === 'agent' || data.endedBy === 'idle-timeout'
@@ -496,7 +582,13 @@ export function applySessionReceipt(data: Record<string, unknown>): void {
       held: Number(counts?.held ?? 0) || 0,
     },
     snapshot:
-      snapshot && typeof snapshot.id === 'string' ? { id: snapshot.id, name: String(snapshot.name ?? '') } : null,
+      snapshot && typeof snapshot.id === 'string'
+        ? {
+            id: snapshot.id,
+            name: String(snapshot.name ?? ''),
+            boardId: typeof snapshot.boardId === 'string' ? snapshot.boardId : null,
+          }
+        : null,
     context: {
       read: receiptNodes(context?.read),
       pinned: receiptNodes(context?.pinned),
@@ -507,17 +599,51 @@ export function applySessionReceipt(data: Record<string, unknown>): void {
   };
   const open = sessionReceipt.value;
   sessionReceipt.value = open ? mergeReceipts(open, next) : next;
-  if (open && activityLensNodeIds.value) setActivityLens(true);
+  // A live lens carries on as the receipt's once its session ends.
+  if (endsLiveLens) activityLens.value = { kind: 'receipt' };
+}
+
+/**
+ * Undo on the receipt's Edited row (AgentContext.dc.html): each card back to
+ * its content in the pre-session snapshot — the rest of the board stays.
+ */
+export async function undoSessionEdits(
+  snapshotId: string,
+  edits: ReceiptNode[],
+): Promise<{ ok: boolean; restored: string[] }> {
+  let ok = true;
+  const restored: string[] = [];
+  for (const edit of edits) {
+    if (edit.boardId && edit.boardId !== activeBoardId.value) continue;
+    const nodeId = edit.id;
+    // A card you edited after the session keeps your edit.
+    const node = nodes.value.get(nodeId);
+    if (!node || node.lastEditedBy?.actor === 'human') continue;
+    const result = await requestJson<{ ok: boolean; restored: boolean }>(
+      'undoSessionEdit',
+      `/api/canvas/snapshots/${encodeURIComponent(snapshotId)}/restore-node`,
+      { ok: false, restored: false },
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ nodeId, preserveHumanEdits: true }),
+      },
+    );
+    ok = ok && result.ok;
+    if (result.ok && result.restored) restored.push(nodeId);
+  }
+  return { ok, restored };
 }
 
 export function dismissSessionReceipt(): void {
   sessionReceipt.value = null;
-  activityLensNodeIds.value = null;
+  if (activityLens.value?.kind === 'receipt') activityLens.value = null;
 }
 
 export function resetSessionStore(): void {
   historyTop.value = null;
   undoneActivityIds.value = new Set();
+  sessionPanelOpened.value = false;
   sessionReceipt.value = null;
   axTimeline.value = { events: [], evidence: [], steering: [] };
   timelineFilter.value = 'all';