@smartmemory/compose 0.1.0 → 0.1.2-beta

package/server/cc-session-reader.js

@@ -0,0 +1,327 @@
+/**
+ * CC JSONL session reader — COMP-OBS-BRANCH T1.
+ *
+ * Walks a single `~/.claude/projects/<slug>/<session-id>.jsonl`, parses records,
+ * builds a parent-pointer tree over non-sidechain records, identifies leaves,
+ * classifies per-branch state, and derives the BranchOutcome metrics required by
+ * the shared Wave 6 contract (docs/features/COMP-OBS-CONTRACT/schema.json).
+ *
+ * Producer-side only. The `feature_code` field is injected later by the watcher
+ * (T5) using the CC-session feature resolver (T2); records emitted here omit it.
+ */
+
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { createHash } from 'node:crypto';
+
+const WRITE_TOOL_NAMES = new Set(['Edit', 'Write', 'NotebookEdit', 'MultiEdit']);
+const TEST_RUNNER_RE = /(pytest|jest|vitest|mocha|node\s+--test|npm\s+(run\s+)?test|go\s+test|cargo\s+test)/i;
+const PASS_FAIL_RE = /(\d+)\s+passed(?:[^\n]*?\s(\d+)\s+failed)?(?:[^\n]*?\s(\d+)\s+skipped)?/i;
+
+function sha1(s) { return createHash('sha1').update(s).digest('hex'); }
+
+function parseJsonlSafe(text) {
+  const out = [];
+  const lines = text.split('\n');
+  let truncated = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      // Any unparseable line (middle or trailing) marks the session as truncated
+      // so the downstream classifier surfaces `unknown` rather than silently dropping
+      // potentially load-bearing records (e.g. a result/error line).
+      truncated = true;
+    }
+  }
+  return { records: out, truncated };
+}
+
+function contentArray(msg) {
+  const c = msg?.content;
+  if (!c) return [];
+  return Array.isArray(c) ? c : [];
+}
+
+function hasIsErrorToolResult(rec) {
+  return rec?.type === 'user' &&
+    contentArray(rec.message).some(item => item?.type === 'tool_result' && item?.is_error === true);
+}
+
+function classifyLeafState(leaf, childrenByParent) {
+  if (!leaf) return 'unknown';
+  if (hasIsErrorToolResult(leaf)) return 'failed';
+  if (leaf.type === 'user') {
+    const hasToolResult = contentArray(leaf.message).some(it => it?.type === 'tool_result');
+    if (hasToolResult) return 'complete';
+  }
+  if (leaf.type === 'assistant') {
+    const stopReason = leaf.message?.stop_reason;
+    if (stopReason === 'end_turn') return 'complete';
+    const hasUse = contentArray(leaf.message).some(it => it?.type === 'tool_use');
+    if (hasUse) {
+      const kids = childrenByParent.get(leaf.uuid) || [];
+      if (kids.length === 0) return 'running';
+    }
+  }
+  return 'unknown';
+}
+
+function walkPath(leafUuid, byUuid) {
+  const path = [];
+  let cur = byUuid.get(leafUuid);
+  while (cur) {
+    path.push(cur);
+    if (!cur.parentUuid) break;
+    cur = byUuid.get(cur.parentUuid);
+  }
+  return path.reverse();
+}
+
+function findForkUuid(path, forkPointUuids) {
+  for (let i = path.length - 1; i >= 0; i--) {
+    if (forkPointUuids.has(path[i].uuid)) return path[i].uuid;
+  }
+  return null;
+}
+
+function firstPostForkIndex(path, forkUuid) {
+  if (!forkUuid) return 0;
+  const idx = path.findIndex(r => r.uuid === forkUuid);
+  return idx >= 0 ? idx + 1 : 0;
+}
+
+function extractMetricsForPath(path, fullRecords) {
+  let turnCount = 0;
+  const fileStats = new Map();
+  let testsPassed = 0, testsFailed = 0, testsSkipped = 0;
+  const runIds = new Set();
+  let tokensIn = 0, tokensOut = 0, cacheReadIn = 0, cacheCreation = 0;
+  let finalArtifact = null;
+  let lastWriteIdx = -1;
+
+  const childrenByParent = new Map();
+  for (const r of fullRecords) {
+    if (!r?.uuid) continue;
+    const p = r.parentUuid || null;
+    if (!childrenByParent.has(p)) childrenByParent.set(p, []);
+    childrenByParent.get(p).push(r);
+  }
+
+  let lastUserTurnIdx = -1;
+  for (let i = 0; i < path.length; i++) {
+    const r = path[i];
+    if (r.type === 'user') {
+      turnCount++;
+      lastUserTurnIdx = i;
+    }
+    if (r.type === 'assistant') {
+      const usage = r.message?.usage || {};
+      tokensIn += (usage.input_tokens || 0);
+      tokensOut += (usage.output_tokens || 0);
+      cacheReadIn += (usage.cache_read_input_tokens || 0);
+      cacheCreation += (usage.cache_creation_input_tokens || 0);
+      for (const item of contentArray(r.message)) {
+        if (item?.type === 'tool_use') {
+          if (WRITE_TOOL_NAMES.has(item.name)) {
+            const filePath = item.input?.file_path;
+            if (filePath) {
+              if (!fileStats.has(filePath)) fileStats.set(filePath, new Set());
+              fileStats.get(filePath).add(lastUserTurnIdx);
+              lastWriteIdx = i;
+            }
+          }
+          if (item.name === 'Bash' && r.requestId) {
+            const cmd = item.input?.command || '';
+            if (TEST_RUNNER_RE.test(cmd)) runIds.add(r.requestId);
+          }
+        }
+      }
+    }
+    if (r.type === 'user') {
+      for (const item of contentArray(r.message)) {
+        if (item?.type === 'tool_result') {
+          const content = item.content;
+          const stdout = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+              ? content.map(c => c?.text || '').join('\n')
+              : '';
+          const m = stdout.match(PASS_FAIL_RE);
+          if (m) {
+            testsPassed += parseInt(m[1] || '0', 10);
+            testsFailed += parseInt(m[2] || '0', 10);
+            testsSkipped += parseInt(m[3] || '0', 10);
+          }
+        }
+      }
+    }
+  }
+
+  if (lastWriteIdx >= 0) {
+    const writeRec = path[lastWriteIdx];
+    for (const item of contentArray(writeRec.message)) {
+      if (item?.type === 'tool_use' && WRITE_TOOL_NAMES.has(item.name)) {
+        const fp = item.input?.file_path;
+        if (!fp) continue;
+        if (fp.includes('docs/features/')) {
+          const kind = inferArtifactKind(fp);
+          finalArtifact = { path: fp, kind, snapshot: null };
+          break;
+        } else if (!finalArtifact) {
+          finalArtifact = { path: fp, kind: inferArtifactKind(fp), snapshot: null };
+        }
+      }
+    }
+  }
+
+  const files = [];
+  for (const [path, turnSet] of fileStats.entries()) {
+    files.push({ path, turns_modified: Math.max(1, turnSet.size) });
+  }
+  return {
+    turnCount,
+    files,
+    tests: {
+      passed: testsPassed,
+      failed: testsFailed,
+      skipped: testsSkipped,
+      run_ids: [...runIds],
+    },
+    cost: {
+      tokens_in: tokensIn,
+      tokens_out: tokensOut,
+      cache_read_input_tokens: cacheReadIn,
+      cache_creation_input_tokens: cacheCreation,
+    },
+    finalArtifact,
+  };
+}
+
+function inferArtifactKind(filePath) {
+  const name = basename(filePath).toLowerCase();
+  if (name === 'design.md') return 'design';
+  if (name === 'plan.md') return 'plan';
+  if (name === 'prd.md') return 'prd';
+  if (name === 'blueprint.md') return 'blueprint';
+  if (name === 'report.md') return 'report';
+  if (name.endsWith('.diff') || name.endsWith('.patch')) return 'diff';
+  if (name.endsWith('.md')) return 'other';
+  return 'other';
+}
+
+function costUsd(tokensIn, tokensOut) {
+  const inRate = Number(process.env.CC_USD_PER_1K_INPUT || 0);
+  const outRate = Number(process.env.CC_USD_PER_1K_OUTPUT || 0);
+  if (!inRate && !outRate) return 0;
+  return (tokensIn / 1000) * inRate + (tokensOut / 1000) * outRate;
+}
+
+export async function readCCSession(jsonlPath) {
+  const cc_session_id = basename(jsonlPath).replace(/\.jsonl$/, '');
+  const raw = readFileSync(jsonlPath, 'utf8');
+  const { records, truncated } = parseJsonlSafe(raw);
+
+  const byUuid = new Map();
+  for (const r of records) {
+    if (r?.uuid && r.isSidechain !== true) byUuid.set(r.uuid, r);
+  }
+
+  const childrenByParent = new Map();
+  for (const r of byUuid.values()) {
+    const p = r.parentUuid || null;
+    if (!childrenByParent.has(p)) childrenByParent.set(p, []);
+    childrenByParent.get(p).push(r);
+  }
+
+  const forkPointUuids = new Set();
+  for (const [parent, kids] of childrenByParent.entries()) {
+    if (parent == null) continue;
+    const userKids = kids.filter(k => k.type === 'user');
+    if (userKids.length >= 2) forkPointUuids.add(parent);
+  }
+
+  const leaves = [];
+  for (const r of byUuid.values()) {
+    const kids = childrenByParent.get(r.uuid) || [];
+    if (kids.length === 0) leaves.push(r);
+  }
+
+  const branches = [];
+  const forkMap = new Map();
+  for (const leaf of leaves) {
+    const path = walkPath(leaf.uuid, byUuid);
+    if (path.length === 0) continue;
+
+    let state = classifyLeafState(leaf, childrenByParent);
+
+    const forkUuid = findForkUuid(path, forkPointUuids);
+    const startIdx = firstPostForkIndex(path, forkUuid);
+    const branchPath = path.slice(startIdx);
+
+    // If any line in the file was unparseable, we may have lost records that
+    // would have classified a `running` leaf as `complete` (a missing tool_result).
+    // `failed` and `complete` both have positive identifications on the leaf itself
+    // (is_error / end_turn) so they remain trustworthy; `running` depends on the
+    // absence of a child record and becomes unreliable under truncation.
+    if (truncated && state === 'running') state = 'unknown';
+
+    const terminal = state === 'complete' || state === 'failed';
+    const startedAtRec = branchPath[0] || path[0];
+    const started_at = startedAtRec?.timestamp || null;
+    const ended_at = terminal ? (leaf.timestamp || null) : null;
+
+    let metrics = null;
+    if (terminal) {
+      metrics = extractMetricsForPath(branchPath, [...byUuid.values()]);
+    }
+
+    const branch_id = sha1(cc_session_id + ':' + leaf.uuid);
+
+    const outcome = {
+      branch_id,
+      cc_session_id,
+      fork_uuid: forkUuid,
+      leaf_uuid: leaf.uuid,
+      parent_branch_id: null,
+      state,
+      started_at,
+      ended_at,
+      turn_count: terminal ? metrics.turnCount : null,
+      files_touched: terminal ? metrics.files : null,
+      tests: terminal ? metrics.tests : null,
+      cost: terminal
+        ? {
+            tokens_in: metrics.cost.tokens_in,
+            tokens_out: metrics.cost.tokens_out,
+            usd: costUsd(metrics.cost.tokens_in, metrics.cost.tokens_out),
+            wall_clock_ms: started_at && ended_at ? Math.max(0, Date.parse(ended_at) - Date.parse(started_at)) : null,
+          }
+        : null,
+      final_artifact: terminal ? metrics.finalArtifact : null,
+      drift_axes_snapshot: null,
+      open_loops_produced: [],
+    };
+
+    if (forkUuid) {
+      if (!forkMap.has(forkUuid)) forkMap.set(forkUuid, []);
+      forkMap.get(forkUuid).push(leaf.uuid);
+    }
+
+    branches.push(outcome);
+  }
+
+  const fork_points = [];
+  for (const [parent_uuid, child_leaf_uuids] of forkMap.entries()) {
+    fork_points.push({ parent_uuid, child_leaf_uuids });
+  }
+
+  return {
+    cc_session_id,
+    branches,
+    fork_points,
+    truncated,
+  };
+}

package/server/cc-session-watcher.js

@@ -0,0 +1,318 @@
+/**
+ * CC-session watcher — COMP-OBS-BRANCH T5.
+ *
+ * Orchestrator that combines:
+ *   - cc-session-reader.js     (T1) — parses one JSONL file
+ *   - cc-session-feature-resolver.js (T2) — resolves cc_session_id → feature_code
+ *   - decision-event-id.js     (T6) — deterministic DecisionEvent ids
+ *
+ * Maintains a per-feature × per-session accumulator so a feature with multiple
+ * CC sessions never has branches clobbered on POST. On each scan, computes the
+ * union BranchLineage per feature, emits DecisionEvents for NEW forks only (via
+ * persisted emitted_event_ids), and POSTs the updated lineage.
+ *
+ * `projectsRoot` is injectable — tests use tmp dirs; production points at
+ * `~/.claude/projects`.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { readCCSession } from './cc-session-reader.js';
+import { CCSessionFeatureResolver } from './cc-session-feature-resolver.js';
+import { branchDecisionEventId, shouldEmit } from './decision-event-id.js';
+
+const DEFAULT_DEBOUNCE_MS = 100;
+
+function listJsonlFiles(projectsRoot) {
+  const out = [];
+  let entries;
+  try { entries = fs.readdirSync(projectsRoot, { withFileTypes: true }); }
+  catch { return out; }
+  for (const ent of entries) {
+    if (!ent.isDirectory()) {
+      if (ent.isFile() && ent.name.endsWith('.jsonl')) {
+        out.push(path.join(projectsRoot, ent.name));
+      }
+      continue;
+    }
+    const subdir = path.join(projectsRoot, ent.name);
+    let files;
+    try { files = fs.readdirSync(subdir); } catch { continue; }
+    for (const f of files) {
+      if (f.endsWith('.jsonl')) out.push(path.join(subdir, f));
+    }
+  }
+  return out;
+}
+
+function uniqById(arr, key) {
+  const seen = new Map();
+  for (const x of arr) {
+    if (!seen.has(x[key])) seen.set(x[key], x);
+  }
+  return [...seen.values()];
+}
+
+export class CCSessionWatcher {
+  constructor({
+    projectsRoot,
+    sessionsFile,
+    featureRoot,
+    findItemIdByFeatureCode,
+    postBranchLineage,
+    broadcastMessage = () => {},
+    now = () => new Date().toISOString(),
+    // COMP-OBS-STATUS: optional deps for post-lineage status broadcast
+    emitStatusSnapshot = null,
+    getState = null,
+    // COMP-OBS-DRIFT: optional deps for post-lineage drift broadcast
+    emitDriftAxes = null,
+    projectRoot = null,
+  }) {
+    if (!projectsRoot) throw new Error('projectsRoot required');
+    if (!sessionsFile) throw new Error('sessionsFile required');
+    if (!featureRoot) throw new Error('featureRoot required');
+    if (typeof findItemIdByFeatureCode !== 'function') throw new Error('findItemIdByFeatureCode required');
+    if (typeof postBranchLineage !== 'function') throw new Error('postBranchLineage required');
+
+    this.projectsRoot = projectsRoot;
+    this.resolver = new CCSessionFeatureResolver({ sessionsFile, featureRoot });
+    this.findItemIdByFeatureCode = findItemIdByFeatureCode;
+    this.postBranchLineage = postBranchLineage;
+    this.broadcastMessage = broadcastMessage;
+    this.now = now;
+    // COMP-OBS-STATUS: optional snapshot emitter (defaults to no-op if not injected)
+    this._emitStatusSnapshot = emitStatusSnapshot;
+    this._getState = getState;
+    // COMP-OBS-DRIFT: optional drift emitter
+    this._emitDriftAxes = emitDriftAxes;
+    this._projectRoot = projectRoot;
+
+    // featureCode → (cc_session_id → BranchOutcome[])
+    this._accum = new Map();
+    // featureCode → Set<emitted_event_id>
+    this._emitted = new Map();
+    this._watcher = null;
+    this._debounce = new Map();
+  }
+
+  _accumFor(fc) {
+    if (!this._accum.has(fc)) this._accum.set(fc, new Map());
+    return this._accum.get(fc);
+  }
+  _emittedFor(fc) {
+    if (!this._emitted.has(fc)) this._emitted.set(fc, new Set());
+    return this._emitted.get(fc);
+  }
+
+  /** Seed emitted_event_ids from persisted lineage (e.g. from prior lineage.emitted_event_ids on server). */
+  seedEmittedEventIds(featureCode, ids) {
+    const s = this._emittedFor(featureCode);
+    for (const id of ids || []) s.add(id);
+  }
+
+  async _scanOne(jsonlPath) {
+    const cc_session_id = path.basename(jsonlPath).replace(/\.jsonl$/, '');
+    const fc = this.resolver.resolve(cc_session_id);
+    if (!fc) return null;
+
+    let result;
+    try { result = await readCCSession(jsonlPath); }
+    catch (err) {
+      console.warn(`[cc-watcher] read failed for ${jsonlPath}: ${err.message}`);
+      return null;
+    }
+
+    const featureScope = `docs/features/${fc}/`;
+    const enriched = result.branches.map(b => {
+      // Reader-side `final_artifact` is chosen before `feature_code` is known, so
+      // a branch that touched multiple feature folders may have picked another
+      // feature's artifact. Re-filter against the resolved feature_code — if the
+      // picked path isn't scoped to this feature, drop the artifact pointer. Lazy
+      // re-selection from the branch path isn't possible here (the reader drops
+      // intermediate state), so the safe behavior is to return null rather than
+      // point at the wrong feature.
+      let fa = b.final_artifact;
+      if (fa && fa.path && !fa.path.includes(featureScope)) fa = null;
+      return { ...b, feature_code: fc, final_artifact: fa };
+    });
+    this._accumFor(fc).set(cc_session_id, enriched);
+    return { featureCode: fc, cc_session_id, result };
+  }
+
+  _aggregate(featureCode) {
+    const sessionMap = this._accumFor(featureCode);
+    const all = [];
+    for (const branches of sessionMap.values()) all.push(...branches);
+    const branches = uniqById(all, 'branch_id');
+    const in_progress_siblings = branches.filter(b => b.state === 'running').map(b => b.branch_id);
+    return {
+      feature_code: featureCode,
+      branches,
+      in_progress_siblings,
+      emitted_event_ids: [...this._emittedFor(featureCode)],
+      last_scan_at: this.now(),
+    };
+  }
+
+  /** Build the DecisionEvent payload for a fork — pure, no side effects. */
+  _buildForkEvent(featureCode, fork) {
+    const eventId = branchDecisionEventId(featureCode, fork.branch_id);
+    return {
+      eventId,
+      message: {
+        type: 'decisionEvent',
+        event: {
+          id: eventId,
+          feature_code: featureCode,
+          timestamp: this.now(),
+          kind: 'branch',
+          title: `New branch ${fork.branch_id.slice(0, 8)}…`,
+          metadata: {
+            branch_id: fork.branch_id,
+            fork_uuid: fork.fork_uuid || null,
+            sibling_branch_ids: fork.sibling_branch_ids || [],
+          },
+        },
+      },
+    };
+  }
+
+  async _flush(featureCodes) {
+    for (const fc of featureCodes) {
+      const itemId = this.findItemIdByFeatureCode(fc);
+      if (!itemId) continue;
+
+      const lineage = this._aggregate(fc);
+
+      const byFork = new Map();
+      for (const b of lineage.branches) {
+        if (!b.fork_uuid) continue;
+        if (!byFork.has(b.fork_uuid)) byFork.set(b.fork_uuid, []);
+        byFork.get(b.fork_uuid).push(b.branch_id);
+      }
+      const forks = [];
+      for (const b of lineage.branches) {
+        if (!b.fork_uuid) continue;
+        forks.push({
+          branch_id: b.branch_id,
+          fork_uuid: b.fork_uuid,
+          sibling_branch_ids: byFork.get(b.fork_uuid) || [],
+        });
+      }
+
+      // Build DecisionEvents for NEW forks only (not yet in emitted set).
+      // Do NOT broadcast yet — we persist the updated emitted_event_ids to the
+      // lineage POST first, so a failure doesn't leak an unpersisted event id.
+      const emitted = this._emittedFor(fc);
+      const newEvents = [];
+      for (const fork of forks) {
+        const { eventId, message } = this._buildForkEvent(fc, fork);
+        if (!shouldEmit(eventId, emitted)) continue;
+        newEvents.push({ eventId, message });
+      }
+
+      // Stage the new event ids in the lineage payload; keep a rollback list.
+      const stagedIds = newEvents.map(e => e.eventId);
+      lineage.emitted_event_ids = [
+        ...emitted,
+        ...stagedIds,
+      ];
+
+      try {
+        await this.postBranchLineage(itemId, lineage);
+      } catch (err) {
+        console.warn(`[cc-watcher] POST lineage failed for ${fc} (${itemId}): ${err.message}`);
+        // Persistence failed → do NOT broadcast. emitted set is NOT updated,
+        // so a later successful POST will replay and persist these events.
+        continue;
+      }
+
+      // POST succeeded → commit event ids to the in-memory dedupe set, then broadcast.
+      for (const { eventId, message } of newEvents) {
+        emitted.add(eventId);
+        this.broadcastMessage(message);
+      }
+
+      // COMP-OBS-DRIFT: emit drift axes before STATUS so STATUS reads fresh drift_axes
+      if (this._emitDriftAxes && this._getState && this._projectRoot) {
+        try {
+          const state = this._getState();
+          const itemId = this.findItemIdByFeatureCode(fc);
+          const it = itemId && state.items?.get ? state.items.get(itemId) : null;
+          if (it) this._emitDriftAxes(this.broadcastMessage, state, it, this._projectRoot, this.now());
+        } catch (err) {
+          console.warn(`[cc-watcher] emitDriftAxes failed for ${fc}: ${err.message}`);
+        }
+      }
+      // COMP-OBS-STATUS: emit status snapshot after branch lineage update
+      if (this._emitStatusSnapshot && this._getState) {
+        try {
+          this._emitStatusSnapshot(this.broadcastMessage, this._getState(), fc, this.now());
+        } catch (err) {
+          console.warn(`[cc-watcher] emitStatusSnapshot failed for ${fc}: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  async fullScan() {
+    const files = listJsonlFiles(this.projectsRoot);
+    const touched = new Set();
+    for (const f of files) {
+      const scanned = await this._scanOne(f);
+      if (scanned) touched.add(scanned.featureCode);
+    }
+    await this._flush(touched);
+    return { files_scanned: files.length, features_touched: [...touched] };
+  }
+
+  async _onFileChange(jsonlPath) {
+    const scanned = await this._scanOne(jsonlPath);
+    if (scanned) await this._flush([scanned.featureCode]);
+  }
+
+  start() {
+    if (this._watcher) return;
+    if (!fs.existsSync(this.projectsRoot)) {
+      fs.mkdirSync(this.projectsRoot, { recursive: true });
+    }
+    try {
+      this._watcher = fs.watch(this.projectsRoot, { recursive: true }, (_evt, filename) => {
+        if (!filename || !filename.endsWith('.jsonl')) return;
+        const full = path.join(this.projectsRoot, filename);
+        const last = this._debounce.get(full) || 0;
+        const now = Date.now();
+        if (now - last < DEFAULT_DEBOUNCE_MS) return;
+        this._debounce.set(full, now);
+        this._onFileChange(full).catch(err => {
+          console.warn(`[cc-watcher] change handler failed: ${err.message}`);
+        });
+      });
+    } catch (err) {
+      console.warn(`[cc-watcher] fs.watch unavailable, falling back to polling: ${err.message}`);
+      this._startPolling();
+    }
+  }
+
+  _startPolling(intervalMs = 2000) {
+    this._pollTimer = setInterval(async () => {
+      const files = listJsonlFiles(this.projectsRoot);
+      for (const f of files) {
+        const stat = fs.statSync(f, { throwIfNoEntry: false });
+        if (!stat) continue;
+        const key = f;
+        const last = this._debounce.get(key) || 0;
+        if (stat.mtimeMs > last) {
+          this._debounce.set(key, stat.mtimeMs);
+          await this._onFileChange(f);
+        }
+      }
+    }, intervalMs);
+  }
+
+  stop() {
+    if (this._watcher) { try { this._watcher.close(); } catch {} this._watcher = null; }
+    if (this._pollTimer) { clearInterval(this._pollTimer); this._pollTimer = null; }
+  }
+}