@polderlabs/bizar 6.3.0 → 7.0.0

package/bizar-dash/src/server/routes/distill.mjs

@@ -0,0 +1,129 @@
+/**
+ * src/server/routes/distill.mjs
+ *
+ * v6.4.0 — F-033 / ADR-174.
+ *
+ * REST surface for the ReasoningBank distillation pipeline.
+ *
+ *   POST /api/distill
+ *     Triggers a single RETRIEVE → JUDGE → DISTILL → CONSOLIDATE run
+ *     over the current vault. Optional JSON body:
+ *       { "since": "<iso8601>" }
+ *     Returns the consolidation result (same shape as the SDK
+ *     `memory_distill` MCP tool plus the in-file path).
+ *
+ *   GET /api/distill/patterns
+ *     Reads the most recent `.bizar/distilled-patterns.json` and
+ *     returns its `patterns` array (filtered by `?tier=` and
+ *     `?promoted=` query params). 404 if the file does not yet
+ *     exist (a distillation run hasn't happened).
+ *
+ *   GET /api/distill/status
+ *     Returns a small status object:
+ *       { file: "<path or null>", patternCount, promotedCount, byTier, generatedAt }
+ *
+ * Mounted at /api/distill/*. The route itself is `Router()`-style so
+ * it composes with the rest of the v3 dashboard API.
+ */
+
+import { Router } from 'express';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const SERVER_ROOT = join(dirname(new URL(import.meta.url).pathname), '..');
+const memoryConsolidator = await import(`${SERVER_ROOT}/memory-consolidator.mjs`).then((m) => m);
+
+const { wrap } = await import('./_shared.mjs').then((m) => m);
+
+/**
+ * Build the distill router. `projectRoot` is the Bizar repo root — it
+ * defaults to `process.cwd()` so that `bizar dashboard --dev` "just
+ * works" when launched from inside a Bizar project.
+ */
+export function createDistillRouter({ projectRoot } = {}) {
+  const root = projectRoot ?? process.cwd();
+  const router = Router();
+
+  // ---------------------------------------------------------------------
+  // POST /api/distill — run the pipeline.
+  // ---------------------------------------------------------------------
+  router.post('/distill', wrap(async (req, res) => {
+    const since = typeof req.body?.since === 'string' ? req.body.since : undefined;
+    const result = memoryConsolidator.runConsolidation({ projectRoot: root, since });
+
+    // Side-effect: write the machine-readable log so the GET route
+    // can serve it without re-running the pipeline.
+    const filePath = memoryConsolidator.writeDistilledPatternsFile(result, {
+      projectRoot: root,
+    });
+
+    res.json({
+      distilled: result.distilled,
+      promoted: result.promoted,
+      patterns: result.patterns,
+      byTier: result.byTier,
+      written: result.written,
+      file: filePath,
+    });
+  }));
+
+  // ---------------------------------------------------------------------
+  // GET /api/distill/patterns — return the patterns.
+  // ---------------------------------------------------------------------
+  router.get('/distill/patterns', wrap(async (req, res) => {
+    const fp = join(root, memoryConsolidator.DISTILLED_PATTERNS_FILE);
+    if (!existsSync(fp)) {
+      res.status(404).json({ error: 'not_distilled_yet', file: fp });
+      return;
+    }
+    const raw = readFileSync(fp, 'utf-8');
+    let payload;
+    try { payload = JSON.parse(raw); }
+    catch (e) { res.status(500).json({ error: 'corrupt_distill_file', message: String(e) }); return; }
+
+    let patterns = Array.isArray(payload.patterns) ? payload.patterns : [];
+
+    const tier = typeof req.query.tier === 'string' ? req.query.tier : null;
+    if (tier) patterns = patterns.filter((p) => p.provenance_tier === tier);
+
+    const promoted = req.query.promoted === 'true'
+      ? true
+      : req.query.promoted === 'false'
+      ? false
+      : null;
+    if (promoted !== null) patterns = patterns.filter((p) => Boolean(p.promoted) === promoted);
+
+    res.json({
+      generatedAt: payload.generatedAt,
+      byTier: payload.byTier,
+      patterns,
+      count: patterns.length,
+    });
+  }));
+
+  // ---------------------------------------------------------------------
+  // GET /api/distill/status — small status object.
+  // ---------------------------------------------------------------------
+  router.get('/distill/status', wrap(async (_req, res) => {
+    const fp = join(root, memoryConsolidator.DISTILLED_PATTERNS_FILE);
+    if (!existsSync(fp)) {
+      res.json({ file: null, patternCount: 0, promotedCount: 0, byTier: null, generatedAt: null });
+      return;
+    }
+    try {
+      const payload = JSON.parse(readFileSync(fp, 'utf-8'));
+      const patterns = Array.isArray(payload.patterns) ? payload.patterns : [];
+      res.json({
+        file: fp,
+        patternCount: patterns.length,
+        promotedCount: patterns.filter((p) => Boolean(p.promoted)).length,
+        byTier: payload.byTier,
+        generatedAt: payload.generatedAt,
+      });
+    } catch (e) {
+      res.status(500).json({ error: 'corrupt_distill_file', message: String(e) });
+    }
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/goal-planner.mjs

@@ -0,0 +1,236 @@
+/**
+ * src/server/routes/goal-planner.mjs
+ *
+ * v6.4.0 — F-036 (Goal Planner UI).
+ *
+ * Single endpoint:
+ *   POST /api/goal-planner/plan { goal } -> Plan
+ *
+ * The planner logic is duplicated here in pure JS so the route
+ * runs without a Vite build step. The canonical implementation
+ * lives in `bizar-dash/src/web/lib/goapPlanner.ts` and produces
+ * the same shape.
+ */
+import { Router } from 'express';
+import { wrap } from './_shared.mjs';
+
+const VERB_TO_ACTION = {
+  research: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Gather context, examples, and prior art.' },
+  investigate: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Probe the unknown regions of the problem.' },
+  explore: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Map the solution space.' },
+  find: { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Locate references and prior work.' },
+  analyze: { name: 'analyze', cost: 1, agent: 'Odin', effect: 'goal_analyzed', preconditions: ['context_gathered'], description: 'Decompose the goal into measurable sub-objectives.' },
+  plan: { name: 'plan', cost: 1, agent: 'Odin', effect: 'plan_drafted', preconditions: ['goal_analyzed'], description: 'Sequence the work into milestones.' },
+  design: { name: 'design', cost: 2, agent: 'Tyr', effect: 'design_drafted', preconditions: ['plan_drafted'], description: 'Sketch the architecture and contracts.' },
+  architect: { name: 'design', cost: 2, agent: 'Tyr', effect: 'design_drafted', preconditions: ['plan_drafted'], description: 'Lay out the system structure.' },
+  build: { name: 'build', cost: 3, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Construct the artifact end-to-end.' },
+  implement: { name: 'implement', cost: 3, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Wire up the code path.' },
+  create: { name: 'implement', cost: 3, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Stand up the new module.' },
+  add: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', preconditions: ['design_drafted'], description: 'Layer the new capability onto an existing surface.' },
+  write: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', description: 'Author the requested artifact.' },
+  fix: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', description: 'Repair the reported defect.' },
+  refactor: { name: 'implement', cost: 2, agent: 'Thor', effect: 'artifact_built', description: 'Improve the structure without changing behavior.' },
+  test: { name: 'test', cost: 2, agent: 'Forseti', effect: 'tests_passing', preconditions: ['artifact_built'], description: 'Exercise the artifact against acceptance criteria.' },
+  verify: { name: 'test', cost: 1, agent: 'Forseti', effect: 'tests_passing', preconditions: ['artifact_built'], description: 'Validate against the original goal statement.' },
+  validate: { name: 'test', cost: 1, agent: 'Forseti', effect: 'tests_passing', preconditions: ['artifact_built'], description: 'Cross-check the result against acceptance criteria.' },
+  review: { name: 'review', cost: 1, agent: 'Forseti', effect: 'review_passed', preconditions: ['artifact_built'], description: 'Audit the change for quality and regressions.' },
+  document: { name: 'document', cost: 1, agent: 'Bragi', effect: 'docs_written', preconditions: ['artifact_built'], description: 'Capture the new knowledge in docs.' },
+  deploy: { name: 'deploy', cost: 2, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing', 'review_passed'], description: 'Promote the artifact to production.' },
+  ship: { name: 'deploy', cost: 2, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing', 'review_passed'], description: 'Release the change to users.' },
+  release: { name: 'deploy', cost: 2, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing', 'review_passed'], description: 'Tag and publish a new version.' },
+  publish: { name: 'deploy', cost: 1, agent: 'Heimdall', effect: 'deployed', preconditions: ['tests_passing'], description: 'Make the artifact externally available.' },
+  commit: { name: 'commit', cost: 1, agent: 'Hermod', effect: 'committed', description: 'Land the change in version control.' },
+  save: { name: 'commit', cost: 1, agent: 'Hermod', effect: 'committed', description: 'Persist the work.' },
+};
+
+const DURATION_MS = {
+  research: 30000, analyze: 20000, plan: 25000, design: 60000,
+  build: 120000, implement: 90000, test: 60000, review: 30000,
+  document: 30000, deploy: 60000, commit: 10000,
+};
+
+const FALLBACK = { name: 'research', cost: 1, agent: 'Odin', effect: 'context_gathered', description: 'Investigate the goal.' };
+
+function splitClauses(text) {
+  // Split on terminal punctuation, conjunctions (then/after/before/and
+  // then), AND commas / the word "and" so that "Design, build, test,
+  // and deploy" produces 4 clauses.
+  const parts = text.split(/[.;!?\n]|\bthen\b|\bafter that\b|\bafter\b|\bbefore\b|\band then\b|\s*,\s*|\band\b/gi);
+  const out = [];
+  for (const part of parts) {
+    const t = part.trim();
+    if (!t) continue;
+    if (!/^[a-zA-Z]+\b/.test(t) && t.includes(',')) {
+      for (const sub of t.split(',')) {
+        const s = sub.trim();
+        if (s) out.push(s);
+      }
+    } else {
+      out.push(t);
+    }
+  }
+  return out;
+}
+
+function stripPolite(body) {
+  let out = body;
+  for (let i = 0; i < 4; i++) {
+    const before = out;
+    out = out.replace(/^(?:please\s+|kindly\s+)/i, '');
+    out = out.replace(/^(?:we should|let's|lets|i want to|i need to|i'd like to|i would like to|can you|could you|would you|help me|help us|make sure to|please)\s+/i, '');
+    if (out === before) break;
+  }
+  return out;
+}
+
+function extractVerb(clause) {
+  const body = stripPolite(clause.trim());
+  const first = (body.split(/\s+/)[0] || '').toLowerCase().replace(/[^a-z]/g, '');
+  return first;
+}
+
+function clauseSubject(clause) {
+  const body = stripPolite(clause.trim());
+  const stripped = body.replace(/^[a-zA-Z]+\s+/, '').trim();
+  return stripped.length > 0 ? stripped : clause;
+}
+
+function aStar(actions, goals) {
+  const goalSet = new Set(goals);
+  if (goalSet.size === 0) return actions.slice(0, 1);
+  const heur = (s) => {
+    let u = 0;
+    for (const g of goalSet) if (!s.has(g)) u++;
+    return u;
+  };
+  const keyOf = (s) => Array.from(s).sort().join('|') || 'empty';
+  const start = { sat: new Set(), path: [], cost: 0 };
+  const open = [start];
+  const closed = new Set();
+  let best = start;
+  while (open.length) {
+    open.sort((a, b) => (a.cost + heur(a.sat)) - (b.cost + heur(b.sat)));
+    const node = open.shift();
+    if (heur(node.sat) === 0) return node.path;
+    if (heur(node.sat) < heur(best.sat)) best = node;
+    const k = keyOf(node.sat);
+    if (closed.has(k)) continue;
+    closed.add(k);
+    for (const a of actions) {
+      const pre = a.preconditions || [];
+      if (!pre.every((p) => node.sat.has(p))) continue;
+      const next = new Set(node.sat);
+      next.add(a.effect);
+      open.push({ sat: next, path: [...node.path, a], cost: node.cost + a.cost });
+    }
+  }
+  return best.path;
+}
+
+function inlinePlan(goalText) {
+  const id = `plan_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  const clauses = splitClauses(goalText);
+  const effective = clauses.length > 0 ? clauses : [(goalText || 'Investigate the goal').trim()];
+  const rawTemplates = effective.map((c) => VERB_TO_ACTION[extractVerb(c)] || FALLBACK);
+  const subjects = effective.map(clauseSubject);
+  const seen = new Set();
+  const dedup = [];
+  for (let i = 0; i < rawTemplates.length; i++) {
+    const t = rawTemplates[i];
+    const s = subjects[i] || `step ${i + 1}`;
+    const sig = `${t.name}::${s.toLowerCase().slice(0, 40)}`;
+    if (seen.has(sig)) continue;
+    seen.add(sig);
+    dedup.push({ template: t, subject: s });
+  }
+  const trimmed = dedup.slice(0, 8);
+  const goalEffects = trimmed.map((d) => d.template.effect);
+  const sequence = aStar(trimmed.map((d) => d.template), goalEffects);
+  const idByEffect = new Map();
+  const steps = [];
+  let n = 0;
+  for (const tpl of sequence) {
+    const match = trimmed.find((s) => s.template === tpl);
+    if (!match) continue;
+    n += 1;
+    const sid = `s${n}`;
+    const deps = [];
+    for (const p of tpl.preconditions || []) {
+      const pid = idByEffect.get(p);
+      if (pid) deps.push(pid);
+    }
+    const title = match.subject.charAt(0).toUpperCase() + match.subject.slice(1);
+    steps.push({
+      id: sid,
+      action: tpl.name,
+      title: title.length > 0 ? title : tpl.name,
+      agent: tpl.agent,
+      description: tpl.description,
+      effects: [tpl.effect],
+      deps,
+      status: 'pending',
+      estimatedCost: tpl.cost,
+      estimatedDurationMs: DURATION_MS[tpl.name] || 30000,
+    });
+    idByEffect.set(tpl.effect, sid);
+  }
+  if (steps.length === 0 && trimmed.length > 0) {
+    let idx = 0;
+    for (const { template, subject } of trimmed) {
+      idx += 1;
+      const sid = `s${idx}`;
+      const deps = [];
+      for (const p of template.preconditions || []) {
+        const pid = idByEffect.get(p);
+        if (pid) deps.push(pid);
+      }
+      const title = subject.charAt(0).toUpperCase() + subject.slice(1);
+      steps.push({
+        id: sid,
+        action: template.name,
+        title: title.length > 0 ? title : template.name,
+        agent: template.agent,
+        description: template.description,
+        effects: [template.effect],
+        deps,
+        status: 'pending',
+        estimatedCost: template.cost,
+        estimatedDurationMs: DURATION_MS[template.name] || 30000,
+      });
+      idByEffect.set(template.effect, sid);
+    }
+  }
+  const totalCost = steps.reduce((sum, s) => sum + s.estimatedCost, 0);
+  const totalDurationMs = steps.reduce((sum, s) => sum + s.estimatedDurationMs, 0);
+  return { id, goal: goalText, steps, totalCost, totalDurationMs, goalEffects };
+}
+
+function readGoal(body) {
+  const raw = body && body.goal;
+  if (typeof raw !== 'string' || !raw.trim()) {
+    const err = new Error('goal (non-empty string) is required');
+    err.status = 400;
+    err.code = 'bad_request';
+    throw err;
+  }
+  if (raw.length > 4000) {
+    const err = new Error('goal must be 4000 chars or fewer');
+    err.status = 400;
+    err.code = 'bad_request';
+    throw err;
+  }
+  return raw.trim();
+}
+
+export function createGoalPlannerRouter({ broadcast } = {}) {
+  const router = Router();
+  router.post('/goal-planner/plan', wrap(async (req, res) => {
+    const goal = readGoal(req.body);
+    const plan = inlinePlan(goal);
+    if (broadcast) {
+      try { broadcast({ type: 'goal:planned', planId: plan.id, goal }); } catch { /* best-effort */ }
+    }
+    res.json(plan);
+  }));
+  return router;
+}

package/bizar-dash/src/web/App.tsx

@@ -42,6 +42,8 @@ import { Doctor } from './views/Doctor';
 import { Harness } from './views/Harness';
 import { Eval } from './views/Eval';
 import { EvalReport } from './views/EvalReport';
+// v6.4.0 — F-036 Goal Planner UI.
+import { GoalPlanner } from './views/GoalPlanner';
 import { SettingsNav } from './components/SettingsNav';
 import { Spinner } from './components/Spinner';
 import { Button } from './components/Button';
@@ -108,6 +110,8 @@ const VIEW_MAP: Record<string, (p: ViewProps) => React.ReactNode> = {
   // Eval view's "Open Eval Report" button (full report + diff).
   eval: Eval,
   evalReport: EvalReport,
+  // v6.4.0 — F-036 Goal Planner UI. Plain-English goal → A* plan.
+  'goal-planner': GoalPlanner,
 };
 
 const VERSION = 'v6.0.0';

package/bizar-dash/src/web/components/Tag.tsx

@@ -1,17 +1,30 @@
 // src/components/Tag.tsx — pill for tags.
 
-import type { ReactNode } from 'react';
+import type { HTMLAttributes, ReactNode } from 'react';
 import { cn } from '../lib/utils';
 
-export type TagProps = {
+export type TagVariant =
+  | "neutral"
+  | "info"
+  | "accent"
+  | "primary"
+  | "success"
+  | "warning"
+  | "error";
+
+export type TagProps = HTMLAttributes<HTMLSpanElement> & {
   children: ReactNode;
   className?: string;
+  variant?: TagVariant;
   onRemove?: () => void;
 };
 
-export function Tag({ children, className, onRemove }: TagProps) {
+export function Tag({ children, className, variant, onRemove, ...rest }: TagProps) {
   return (
-    <span className={cn('tag', className)}>
+    <span
+      className={cn('tag', variant ? `tag-${variant}` : undefined, className)}
+      {...rest}
+    >
       {children}
       {onRemove && (
         <button
@@ -25,4 +38,4 @@ export function Tag({ children, className, onRemove }: TagProps) {
       )}
     </span>
   );
-}
+}

package/bizar-dash/src/web/components/Topbar.tsx

@@ -26,6 +26,7 @@ import {
   Brain,
   Stethoscope,
   ClipboardCheck,
+  Target,
   type LucideIcon,
 } from 'lucide-react';
 import { cn } from '../lib/utils';
@@ -66,6 +67,8 @@ export const TABS: TabDef[] = [
   { id: 'doctor', label: 'Doctor', icon: Stethoscope },
   // v6.0.0 — Harness engineering dashboard.
   { id: 'harness', label: 'Harness', icon: Shield },
+  // v6.4.0 — F-036 Goal Planner UI. Plain-English → A* plan.
+  { id: 'goal-planner', label: 'Goals', icon: Target },
   { id: 'settings', label: 'Settings', icon: Sliders },
 ];
 

package/bizar-dash/src/web/components/agents/CommunicationLog.tsx

@@ -0,0 +1,126 @@
+// src/web/components/agents/CommunicationLog.tsx — inter-agent message bus trace.
+//
+// v6.4.0 — F-036 (Goal Planner UI). Subscribes to ws.ts for any
+// event whose type starts with `agent:` and renders the last 200
+// messages with color coding by type. Bounded virtual-list window
+// so a runaway stream can't blow up the page.
+import { useEffect, useState } from 'react';
+import { MessageSquare, ArrowRight } from 'lucide-react';
+import { Ws } from '../../lib/ws';
+import { Card, CardTitle, CardMeta } from '../Card';
+import { Tag } from '../Tag';
+
+const MAX_ROWS = 200;
+
+type Entry = {
+  id: string;
+  ts: number;
+  from: string;
+  to: string;
+  message: string;
+  kind: 'info' | 'request' | 'success' | 'warning' | 'error' | 'status' | 'restarted' | 'stuck' | 'message';
+  raw: unknown;
+};
+
+function classify(t: string): Entry['kind'] {
+  if (t === 'agent:status') return 'status';
+  if (t === 'agent:restarted') return 'restarted';
+  if (t === 'agent:stuck') return 'stuck';
+  if (t === 'agent:message') return 'message';
+  return 'info';
+}
+
+function deriveEntry(t: string, payload: Record<string, unknown> | undefined, ts: number): Entry {
+  const kind = classify(t);
+  const id = `${ts}-${Math.random().toString(36).slice(2, 7)}`;
+  if (t === 'agent:message') {
+    const m = (payload?.message || payload) as Record<string, unknown>;
+    return {
+      id,
+      ts,
+      from: String(m?.from || 'unknown'),
+      to: String(m?.to || 'unknown'),
+      message: String(m?.text || m?.message || JSON.stringify(m).slice(0, 160)),
+      kind,
+      raw: payload,
+    };
+  }
+  const agent = (payload?.agent || payload) as Record<string, unknown>;
+  const name = String(agent?.name || 'agent');
+  return {
+    id,
+    ts,
+    from: name,
+    to: kind === 'stuck' ? 'orchestrator' : 'broadcast',
+    message: `${t} ${agent?.status ? `→ ${agent.status}` : ''}`.trim(),
+    kind,
+    raw: payload,
+  };
+}
+
+interface Props {
+  /** Override the max row count (default 200). */
+  maxRows?: number;
+}
+
+export function CommunicationLog({ maxRows = MAX_ROWS }: Props) {
+  const [rows, setRows] = useState<Entry[]>([]);
+
+  useEffect(() => {
+    const ws = new Ws();
+    const off = ws.on((msg) => {
+      const t = (msg as { type?: string }).type;
+      if (!t || !t.startsWith('agent:')) return;
+      const m = msg as { type: string; ts?: number } & Record<string, unknown>;
+      const ts = Number(m.ts) || Date.now();
+      setRows((prev) => {
+        const next = [...prev, deriveEntry(t, m as Record<string, unknown>, ts)];
+        return next.length > maxRows ? next.slice(next.length - maxRows) : next;
+      });
+    });
+    return () => {
+      off();
+      ws.close();
+    };
+  }, [maxRows]);
+
+  return (
+    <Card className="comm-log" data-testid="communication-log">
+      <div className="comm-log-header">
+        <CardTitle>
+          <MessageSquare size={14} aria-hidden /> Communication log
+        </CardTitle>
+        <Tag variant="neutral" data-testid="communication-log-count">{rows.length}</Tag>
+      </div>
+      <CardMeta>Inter-agent message bus trace · bounded to {maxRows} rows</CardMeta>
+      <ul className="comm-log-list" data-testid="communication-log-list">
+        {rows.length === 0 && (
+          <li className="comm-log-empty" data-testid="communication-log-empty">
+            No agent messages yet. Stream will appear here live.
+          </li>
+        )}
+        {rows.slice().reverse().map((row) => (
+          <li
+            key={row.id}
+            className={`comm-log-row is-${row.kind}`}
+            data-testid="communication-log-row"
+            data-kind={row.kind}
+          >
+            <div className="comm-log-row-meta">
+              <span className="comm-log-from">{row.from}</span>
+              <ArrowRight size={12} aria-hidden />
+              <span className="comm-log-to">{row.to}</span>
+              <Tag variant="neutral" className={`comm-log-kind is-${row.kind}`}>{row.kind}</Tag>
+              <time className="comm-log-time" dateTime={new Date(row.ts).toISOString()}>
+                {new Date(row.ts).toLocaleTimeString()}
+              </time>
+            </div>
+            <div className="comm-log-message">{row.message}</div>
+          </li>
+        ))}
+      </ul>
+    </Card>
+  );
+}
+
+export default CommunicationLog;