a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/summarizer.js

@@ -0,0 +1,156 @@
+/**
+ * Conversation summarizer for A2A
+ * 
+ * Provides a default summarizer interface and a simple implementation.
+ * OpenClaw installations can provide their own summarizer via config.
+ */
+
+const { createLogger } = require('./logger');
+
+const logger = createLogger({ component: 'a2a.summarizer' });
+
+/**
+ * Default summarizer using simple extraction (no LLM)
+ * Returns basic summary without owner context
+ */
+function defaultSummarizer(messages, ownerContext = {}) {
+  if (!messages || messages.length === 0) {
+    return { summary: null };
+  }
+
+  // Extract key information
+  const messageCount = messages.length;
+  const firstMessage = messages[0];
+  const lastMessage = messages[messages.length - 1];
+  const inboundCount = messages.filter(m => m.direction === 'inbound').length;
+  const outboundCount = messages.filter(m => m.direction === 'outbound').length;
+
+  // Simple extractive summary (first message + last message)
+  const summary = `${messageCount} messages exchanged. Started: "${truncate(firstMessage.content, 100)}". Ended: "${truncate(lastMessage.content, 100)}"`;
+
+  return {
+    summary,
+    ownerSummary: null, // No owner context without LLM
+    relevance: 'unknown',
+    goalsTouched: [],
+    actionItems: [],
+    followUp: null,
+    notes: null
+  };
+}
+
+/**
+ * Create a summarizer that uses an LLM via a callback
+ * 
+ * @param {function} llmCall - async function(prompt) => string
+ * @returns {function} summarizer function
+ */
+function createLLMSummarizer(llmCall) {
+  return async function(messages, ownerContext = {}) {
+    if (!messages || messages.length === 0) {
+      return { summary: null };
+    }
+
+    // Format messages for prompt
+    const messageText = messages.map(m => {
+      const role = m.direction === 'inbound' ? 'Caller' : 'You';
+      return `${role}: ${m.content}`;
+    }).join('\n');
+
+    // Build owner context section
+    let ownerSection = '';
+    if (ownerContext.goals) {
+      ownerSection += `\nOwner's current goals:\n${ownerContext.goals.join('\n- ')}`;
+    }
+    if (ownerContext.interests) {
+      ownerSection += `\nOwner's interests:\n${ownerContext.interests.join('\n- ')}`;
+    }
+    if (ownerContext.context) {
+      ownerSection += `\nAdditional context:\n${ownerContext.context}`;
+    }
+
+    const prompt = `You are summarizing a conversation between two AI agents for the receiving agent's owner.
+${ownerSection}
+
+Conversation:
+${messageText}
+
+Provide a JSON response with:
+{
+  "summary": "Brief neutral summary of what was discussed",
+  "ownerSummary": "Summary from the owner's perspective - what does this mean for them?",
+  "relevance": "low/medium/high - how relevant to owner's goals",
+  "goalsTouched": ["list", "of", "goals", "this", "relates", "to"],
+  "actionItems": ["any", "action", "items", "for", "owner"],
+  "followUp": "Suggested follow-up if any",
+  "notes": "Any other relevant notes for the owner"
+}
+
+JSON response:`;
+
+    try {
+      const response = await llmCall(prompt);
+      // Extract JSON from response
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+      // Fallback if JSON extraction fails
+      return {
+        summary: response,
+        ownerSummary: null,
+        relevance: 'unknown',
+        goalsTouched: [],
+        actionItems: [],
+        followUp: null,
+        notes: null
+      };
+    } catch (err) {
+      logger.error('LLM summarization failed', {
+        event: 'llm_summary_failed',
+        error: err,
+        error_code: 'LLM_SUMMARIZATION_FAILED',
+        hint: 'Verify upstream summarizer model availability and prompt JSON output format.',
+        data: {
+          message_count: messages.length
+        }
+      });
+      return defaultSummarizer(messages, ownerContext);
+    }
+  };
+}
+
+/**
+ * Summarizer that calls OpenClaw's sessions_send to use the main agent
+ * This allows using the owner's configured model
+ */
+function createOpenClawSummarizer(openclawConfig = {}) {
+  return async function(messages, ownerContext = {}) {
+    // This would integrate with OpenClaw's internal APIs
+    // For now, fall back to default
+    logger.warn('OpenClaw summarizer not yet integrated, using default summarizer', {
+      event: 'openclaw_summary_not_integrated',
+      error_code: 'OPENCLAW_SUMMARIZER_NOT_INTEGRATED',
+      hint: 'Configure runtime adapter summary command or OpenClaw internal summarizer endpoint.',
+      data: {
+        has_openclaw_config: Boolean(openclawConfig && Object.keys(openclawConfig).length)
+      }
+    });
+    return defaultSummarizer(messages, ownerContext);
+  };
+}
+
+/**
+ * Truncate string with ellipsis
+ */
+function truncate(str, maxLen) {
+  if (!str) return '';
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen - 3) + '...';
+}
+
+module.exports = {
+  defaultSummarizer,
+  createLLMSummarizer,
+  createOpenClawSummarizer
+};

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/summary-formatter.js

@@ -0,0 +1,168 @@
+/**
+ * Summary Formatter
+ *
+ * Renders the structured JSON summary into a human-readable markdown
+ * format. Designed to be scannable, upbeat, and genuinely useful.
+ *
+ * Layout: most important info at the top, details below.
+ *
+ *   1. Headline (one sentence — the takeaway)
+ *   2. Quick Take (3 bullets — what happened, what to do)
+ *   3. Collaboration score + rating
+ *   4. Next Steps (actionable checklist)
+ *   5. --- separator ---
+ *   6. Details: who, exchange, disclosure, objectives, trust
+ */
+
+const VIBE_LABELS = {
+  productive: 'Productive call',
+  exploratory: 'Exploratory — still feeling things out',
+  mismatch: 'Friendly but not much overlap',
+  guarded: 'Guarded — worth reviewing',
+  breakthrough: 'Great connection — real momentum'
+};
+
+/**
+ * Render a structured summary JSON object into human-readable markdown.
+ *
+ * @param {object} summary - The JSON output from the summary prompt
+ * @returns {string} Formatted markdown
+ */
+function formatSummary(summary) {
+  const lines = [];
+  const s = summary;
+
+  // ── Headline ──
+  lines.push(`# Call with ${s.who?.name || 'Unknown'}`);
+  lines.push('');
+  lines.push(`**${s.headline}**`);
+  lines.push('');
+
+  // ── Vibe + Score one-liner ──
+  const vibeLabel = VIBE_LABELS[s.vibe] || s.vibe;
+  const scoreStr = s.collaboration?.score != null
+    ? ` | Overlap: ${s.collaboration.score.toFixed(2)}/1.00`
+    : '';
+  lines.push(`*${vibeLabel}${scoreStr}* \`${s.vibe}\``);
+  lines.push('');
+
+  // ── Quick Take ──
+  if (s.quickTake?.length) {
+    lines.push('### Quick Take');
+    for (const item of s.quickTake) {
+      lines.push(`- ${item}`);
+    }
+    lines.push('');
+  }
+
+  // ── Collaboration ──
+  if (s.collaboration) {
+    const c = s.collaboration;
+    lines.push(`### Collaboration: ${c.rating || 'N/A'}`);
+    if (c.scoreJustification) {
+      lines.push(c.scoreJustification);
+    }
+    if (c.opportunities?.length) {
+      lines.push('');
+      for (const opp of c.opportunities) {
+        lines.push(`- ${opp}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // ── Next Steps ──
+  if (s.nextSteps?.length) {
+    lines.push('### Next Steps');
+    for (const step of s.nextSteps) {
+      lines.push(`- [ ] ${step}`);
+    }
+    lines.push('');
+  }
+
+  // ── Separator ──
+  lines.push('---');
+  lines.push('');
+
+  // ── Details Section ──
+  lines.push('### Details');
+  lines.push('');
+
+  // Who
+  if (s.who) {
+    lines.push(`**Who:** ${s.who.name || 'Unknown'}${s.who.represents ? ` — ${s.who.represents}` : ''}`);
+    if (s.who.keyFacts?.length) {
+      for (const fact of s.who.keyFacts) {
+        lines.push(`- ${fact}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Exchange
+  if (s.exchange) {
+    lines.push('**What We Exchanged**');
+    if (s.exchange.weGot?.length) {
+      lines.push(`- Got: ${s.exchange.weGot.join('; ')}`);
+    }
+    if (s.exchange.weGave?.length) {
+      lines.push(`- Gave: ${s.exchange.weGave.join('; ')}`);
+    }
+    if (s.exchange.balance) {
+      lines.push(`- Balance: ${s.exchange.balance}`);
+    }
+    lines.push('');
+  }
+
+  // Disclosure
+  if (s.disclosure) {
+    const d = s.disclosure;
+    const complianceLabel = d.compliance === 'clean' ? 'Clean — no issues'
+      : d.compliance === 'minor_concern' ? 'Minor concern — review below'
+      : d.compliance === 'violation' ? 'VIOLATION — action required'
+      : d.compliance;
+
+    lines.push(`**Disclosure:** ${complianceLabel} \`${d.compliance}\``);
+    if (d.topicsCovered?.length) {
+      lines.push(`- Covered: ${d.topicsCovered.join(', ')}`);
+    }
+    if (d.topicsAvoided?.length) {
+      lines.push(`- Properly avoided: ${d.topicsAvoided.join(', ')}`);
+    }
+    if (d.concerns?.length) {
+      for (const concern of d.concerns) {
+        lines.push(`- **Concern:** ${concern}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Objectives
+  if (s.objectives) {
+    const o = s.objectives;
+    const parts = [];
+    if (o.achieved?.length) parts.push(`Achieved: ${o.achieved.join(', ')}`);
+    if (o.partiallyAchieved?.length) parts.push(`In progress: ${o.partiallyAchieved.join(', ')}`);
+    if (o.notAchieved?.length) parts.push(`Not addressed: ${o.notAchieved.join(', ')}`);
+    if (parts.length) {
+      lines.push('**Objectives**');
+      for (const p of parts) lines.push(`- ${p}`);
+      lines.push('');
+    }
+  }
+
+  // Trust
+  if (s.trust) {
+    lines.push(`**Trust:** ${s.trust.level}${s.trust.reasoning ? ` — ${s.trust.reasoning}` : ''}`);
+    lines.push('');
+  }
+
+  // Assessment
+  if (s.assessment) {
+    lines.push(`**Bottom line:** ${s.assessment}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { formatSummary, VIBE_LABELS };

package/.claude/worktrees/agent-acefedbd/.claude/worktrees/agent-a04dc0fe/src/lib/summary-prompt.js

@@ -0,0 +1,203 @@
+/**
+ * Unified Summary Prompt Builder
+ *
+ * Builds a comprehensive summary prompt that includes all context
+ * needed for accurate, auditable conversation summaries:
+ *
+ *   - Conversation objective (why the call happened)
+ *   - Disclosure manifest (what's in scope for this tier)
+ *   - Collaboration state (phase, overlap score, threads)
+ *   - Full transcript
+ *   - Owner context
+ *
+ * Used by both OpenClaw and spawned-agent summary paths.
+ */
+
+/**
+ * Build a unified summary prompt with full context.
+ *
+ * @param {object} options
+ * @param {Array} options.transcript - [{direction, content}]
+ * @param {object} options.callerInfo - {name, owner, context}
+ * @param {string} [options.conversationObjective] - Why this call was made
+ * @param {object} [options.disclosure] - {topics, objectives, doNotDiscuss, neverDisclose}
+ * @param {object} [options.collaborationState] - {phase, overlapScore, activeThreads, ...}
+ * @param {object} [options.ownerContext] - {agentName, ownerName, goals}
+ * @returns {string} The complete prompt
+ */
+function buildUnifiedSummaryPrompt(options = {}) {
+  const {
+    transcript = [],
+    callerInfo = {},
+    conversationObjective,
+    disclosure,
+    collaborationState,
+    ownerContext = {}
+  } = options;
+
+  const sections = [];
+
+  // ── Header ──
+  sections.push(`You just finished an A2A agent-to-agent call. Summarize it for your owner.
+
+Your tone: friendly, clear, and genuinely helpful. Lead with what matters most.
+Write like you're briefing a smart friend — not filing a report.`);
+
+  // ── Conversation Objective ──
+  if (conversationObjective) {
+    sections.push(`## Why This Call Happened
+${conversationObjective}`);
+  }
+
+  // ── Owner Context ──
+  if (ownerContext.agentName || ownerContext.ownerName || ownerContext.goals) {
+    const parts = [];
+    if (ownerContext.agentName) parts.push(`You are: ${ownerContext.agentName}`);
+    if (ownerContext.ownerName) parts.push(`Your owner: ${ownerContext.ownerName}`);
+    if (ownerContext.goals?.length) {
+      parts.push(`Owner's current goals:\n${ownerContext.goals.map(g => `- ${g}`).join('\n')}`);
+    }
+    sections.push(`## Your Owner\n${parts.join('\n')}`);
+  }
+
+  // ── Disclosure Manifest ──
+  if (disclosure) {
+    const discParts = [];
+
+    if (disclosure.topics?.length) {
+      discParts.push('### Topics In Scope');
+      for (const t of disclosure.topics) {
+        discParts.push(`- **${t.topic}**: ${t.description}`);
+      }
+    }
+
+    if (disclosure.objectives?.length) {
+      discParts.push('\n### Conversation Objectives');
+      for (const o of disclosure.objectives) {
+        const label = o.objective || o.topic;
+        discParts.push(`- **${label}**: ${o.description}`);
+      }
+    }
+
+    if (disclosure.doNotDiscuss?.length) {
+      discParts.push('\n### Do Not Discuss (Deflect These)');
+      for (const d of disclosure.doNotDiscuss) {
+        discParts.push(`- **${d.topic}**: ${d.reason}`);
+      }
+    }
+
+    if (disclosure.neverDisclose?.length) {
+      discParts.push('\n### Never Disclose (Hard Blocks)');
+      for (const n of disclosure.neverDisclose) {
+        discParts.push(`- ${n}`);
+      }
+    }
+
+    sections.push(`## Disclosure Boundaries\nThese are the rules your agent operated under. Check whether they were followed.\n\n${discParts.join('\n')}`);
+  }
+
+  // ── Collaboration State ──
+  if (collaborationState) {
+    const cs = collaborationState;
+    sections.push(`## Collaboration State at End of Call
+- **Phase:** ${cs.phase || 'unknown'} (handshake -> exploring -> deepening -> converging -> close)
+- **Overlap Score:** ${cs.overlapScore != null ? cs.overlapScore.toFixed(2) : 'unknown'}/1.00
+- **Turn Count:** ${cs.turnCount || 'unknown'}
+- **Active Threads:** ${cs.activeThreads?.length ? cs.activeThreads.join(', ') : 'none identified'}
+- **Candidate Collaborations:** ${cs.candidateCollaborations?.length ? cs.candidateCollaborations.join(', ') : 'none yet'}
+- **Close Signal:** ${cs.closeSignal ? 'yes' : 'no'}
+
+### What Overlap Score Means
+- 0.00–0.30: Minimal alignment — different domains, graceful mismatch expected
+- 0.30–0.60: Moderate — some shared interests, worth exploring
+- 0.60–0.80: Strong — clear mutual value, specific opportunities emerging
+- 0.80–1.00: Deep alignment — ready for concrete collaboration`);
+  }
+
+  // ── Transcript ──
+  const callerLabel = callerInfo.name || 'Caller';
+  const messageText = transcript.map(m => {
+    const role = m.direction === 'inbound' ? `[${callerLabel}]` : '[You]';
+    return `${role}: ${m.content}`;
+  }).join('\n\n');
+
+  sections.push(`## Caller
+${callerInfo.name ? `**Name:** ${callerInfo.name}` : 'Unknown caller'}
+${callerInfo.owner ? `**Represents:** ${callerInfo.owner}` : ''}
+${callerInfo.context ? `**Context:** ${callerInfo.context}` : ''}`);
+
+  sections.push(`## Full Transcript\n${messageText}`);
+
+  // ── Output Instructions ──
+  sections.push(`## Your Task
+
+Summarize this call. Return valid JSON matching this exact schema:
+
+{
+  "headline": "One sentence — the single most important takeaway for the owner",
+
+  "vibe": "productive | exploratory | mismatch | guarded | breakthrough",
+
+  "quickTake": [
+    "Most important discovery or outcome",
+    "Key opportunity or concern",
+    "Recommended immediate action"
+  ],
+
+  "who": {
+    "name": "Caller name",
+    "represents": "Who they work for or represent",
+    "keyFacts": ["Notable fact 1", "Notable fact 2"]
+  },
+
+  "collaboration": {
+    "score": 0.00,
+    "scoreJustification": "Why this score — what aligned, what didn't",
+    "rating": "HIGH | MEDIUM | LOW",
+    "opportunities": ["Specific opportunity with details"]
+  },
+
+  "exchange": {
+    "weGot": ["Info or value we received"],
+    "weGave": ["Info or value we shared"],
+    "balance": "favorable | even | unfavorable"
+  },
+
+  "disclosure": {
+    "compliance": "clean | minor_concern | violation",
+    "topicsCovered": ["In-scope topics that were discussed"],
+    "topicsAvoided": ["Topics that were properly deflected"],
+    "concerns": ["Any info shared that shouldn't have been, or empty array"]
+  },
+
+  "objectives": {
+    "achieved": ["Objectives that were met"],
+    "partiallyAchieved": ["Objectives with some progress"],
+    "notAchieved": ["Objectives not addressed"]
+  },
+
+  "nextSteps": [
+    "Specific actionable follow-up 1",
+    "Specific actionable follow-up 2"
+  ],
+
+  "trust": {
+    "level": "maintain | increase | decrease | revoke",
+    "reasoning": "One sentence — why this trust recommendation"
+  },
+
+  "assessment": "One sentence — strategic value judgment for the owner"
+}
+
+Important:
+- Validate the collaboration score — does it match what actually happened in the conversation?
+- Check disclosure compliance — was any never_disclose or do_not_discuss info leaked?
+- Be honest about objectives — don't inflate partial progress into "achieved"
+- quickTake should be genuinely useful, not generic platitudes
+
+JSON:`);
+
+  return sections.join('\n\n');
+}
+
+module.exports = { buildUnifiedSummaryPrompt };