a2acalling 0.6.48 → 0.6.49

package/src/lib/config.js

@@ -233,6 +233,14 @@ const DEFAULT_CONFIG = {
     description: '',
     hostname: ''
   },
+
+  // Auto-updater
+  auto_update: {
+    enabled: true,
+    intervalMs: 60 * 60 * 1000,
+    allowMajor: false,
+    lastGoodVersion: null
+  },
   
   // Timestamps
   createdAt: null,
@@ -381,6 +389,39 @@ class A2AConfig {
     return this.config;
   }
 
+  getAutoUpdate() {
+    const current = (this.config && typeof this.config.auto_update === 'object' && this.config.auto_update)
+      ? this.config.auto_update
+      : {};
+    return {
+      enabled: current.enabled !== false,
+      intervalMs: Number.isFinite(current.intervalMs) && current.intervalMs > 0
+        ? current.intervalMs
+        : DEFAULT_CONFIG.auto_update.intervalMs,
+      allowMajor: Boolean(current.allowMajor),
+      lastGoodVersion: current.lastGoodVersion || null
+    };
+  }
+
+  setAutoUpdate(patch = {}) {
+    const current = this.getAutoUpdate();
+    const next = { ...current };
+    if (patch.enabled !== undefined) next.enabled = Boolean(patch.enabled);
+    if (patch.intervalMs !== undefined) {
+      const parsed = Number.parseInt(String(patch.intervalMs), 10);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        next.intervalMs = parsed;
+      }
+    }
+    if (patch.allowMajor !== undefined) next.allowMajor = Boolean(patch.allowMajor);
+    if (patch.lastGoodVersion !== undefined) {
+      next.lastGoodVersion = patch.lastGoodVersion ? String(patch.lastGoodVersion).trim() : null;
+    }
+    this.config.auto_update = next;
+    this._save();
+    return next;
+  }
+
   // Export for sharing
   export() {
     return {

package/src/lib/conversation-driver.js

@@ -21,6 +21,7 @@ const {
 } = require('./prompt-template');
 const { getTopicsForTier, formatTopicsForPrompt, loadManifest } = require('./disclosure');
 const { createLogger } = require('./logger');
+const { buildUnifiedSummaryPrompt } = require('./summary-prompt');
 
 const logger = createLogger({ component: 'a2a.conversation-driver' });
 
@@ -143,37 +144,75 @@ class ConversationDriver {
   _buildSummarizer() {
     const runtime = this.runtime;
     const agentContext = this.agentContext;
+    const caller = this.caller;
+    const tier = this.tier;
 
     return async (messages, ownerContext) => {
       if (!messages || messages.length === 0) {
         return { summary: null };
       }
 
-      // Build the summary prompt (same structure as server.js generateSummary)
-      const messageText = messages.map(m => {
-        const role = m.direction === 'inbound' ? '[Them]' : '[You]';
-        return `${role}: ${m.content}`;
-      }).join('\n');
+      // Build transcript in unified format
+      const transcript = messages.map(m => ({
+        direction: m.direction,
+        content: m.content
+      }));
 
-      const prompt = `Summarize this A2A call for the owner. Write from the owner's perspective.
-
-You initiated this call.
-
-Conversation:
-${messageText}
+      // Load disclosure manifest for the tier
+      let disclosure = null;
+      try {
+        const tierTopics = getTopicsForTier(tier);
+        if (tierTopics) {
+          disclosure = {
+            topics: tierTopics.topics || [],
+            objectives: tierTopics.objectives || [],
+            doNotDiscuss: tierTopics.do_not_discuss || [],
+            neverDisclose: tierTopics.never_disclose || []
+          };
+        }
+      } catch (e) {
+        // Disclosure is optional — continue without it
+      }
 
-Structure your summary with these sections:
+      // Look up collaboration state from convStore if available
+      let collaborationState = null;
+      if (this.convStore) {
+        try {
+          const dbState = this.convStore.loadCollabState(this.lastConversationId || '');
+          if (dbState) {
+            collaborationState = {
+              phase: dbState.phase,
+              overlapScore: dbState.overlapScore,
+              turnCount: dbState.turnCount,
+              activeThreads: dbState.activeThreads,
+              candidateCollaborations: dbState.candidateCollaborations,
+              closeSignal: dbState.closeSignal
+            };
+          }
+        } catch (e) {
+          // Best effort
+        }
+      }
 
-**Who:** Who you called, who they represent, key facts about them.
-**Key Discoveries:** What was learned about the other side — capabilities, interests, blind spots.
-**Collaboration Potential:** Rate HIGH/MEDIUM/LOW. List specific opportunities identified.
-**What We Learned vs Shared:** Brief information exchange audit — what did we get, what did we give.
-**Recommended Follow-Up:**
-- [ ] Actionable item 1
-- [ ] Actionable item 2
-**Assessment:** One-sentence strategic value judgment.
+      // Map ownerContext into unified format
+      const unifiedOwnerContext = {
+        agentName: agentContext.name,
+        ownerName: agentContext.owner,
+        goals: ownerContext?.goals || []
+      };
 
-Be concise but specific. No filler.`;
+      const prompt = buildUnifiedSummaryPrompt({
+        transcript,
+        callerInfo: {
+          name: caller.name || null,
+          owner: caller.owner || null,
+          context: caller.context || null
+        },
+        conversationObjective: 'You initiated this call.',
+        disclosure,
+        collaborationState,
+        ownerContext: unifiedOwnerContext
+      });
 
       // Try runtime.summarize if available (OpenClaw path)
       if (typeof runtime.summarize === 'function') {
@@ -505,6 +544,8 @@ Be concise but specific. No filler.`;
     }
 
     // Conclude locally with summarizer
+    // Store conversationId so _buildSummarizer can look up collab state
+    this.lastConversationId = conversationId;
     let summary = null;
     if (this.convStore) {
       try {

package/src/lib/openclaw-integration.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const { createLogger } = require('./logger');
+const { buildUnifiedSummaryPrompt } = require('./summary-prompt');
 
 const logger = createLogger({ component: 'a2a.openclaw-integration' });
 
@@ -89,73 +90,28 @@ function loadOwnerContext(workspaceDir = process.cwd(), options = {}) {
  * Track the exchange balance AND surface partnership opportunities.
  */
 function buildSummaryPrompt(messages, ownerContext, callerInfo = {}) {
-  const messageText = messages.map(m => {
-    const role = m.direction === 'inbound' ? `[Caller${callerInfo.name ? ` - ${callerInfo.name}` : ''}]` : '[You]';
-    return `${role}: ${m.content}`;
-  }).join('\n\n');
-
-  const goalsSection = ownerContext.goals?.length ? `### Current Goals\n- ${ownerContext.goals.join('\n- ')}` : '';
-  const interestsSection = ownerContext.interests?.length ? `### Interests\n- ${ownerContext.interests.join('\n- ')}` : '';
-
-  return `You just finished an A2A agent-to-agent call. Analyze it strategically for your owner.
-
-## Philosophy
-A2A is cooperative AND adversarial. Each agent maximizes value for their own owner — but the best outcomes are mutual wins. Your job:
-
-1. **Track the exchange** — what did we get vs give?
-2. **Find mutual value** — what can BOTH parties gain?
-3. **Surface alignment** — does this connect to owner's goals?
-4. **Advise strategically** — protect interests while building relationships
-
-## Your Owner's Context
-${ownerContext.user ? `### From USER.md\n${ownerContext.user.slice(0, 2000)}` : ''}
-
-${goalsSection}
-
-${interestsSection}
-
-## The Conversation
-${messageText}
-
-## Caller Context
-${callerInfo.name ? `Name: ${callerInfo.name}` : 'Unknown caller'}
-${callerInfo.context ? `Context: ${callerInfo.context}` : ''}
-
-## Your Task
-Analyze as a strategic advisor. Return JSON:
-
-{
-  "who": "Who called, who they represent, key facts about them",
-
-  "keyDiscoveries": ["What was learned about the other side — capabilities, interests, blind spots"],
-
-  "collaborationPotential": {
-    "rating": "HIGH | MEDIUM | LOW",
-    "opportunities": ["specific opportunities identified"]
-  },
-
-  "exchange": {
-    "weGot": ["info, commitments, or value we extracted"],
-    "weGave": ["info, compute, or commitments we provided"],
-    "balance": "favorable | even | unfavorable"
-  },
-
-  "recommendedFollowUp": ["actionable items with specifics"],
-
-  "assessment": "One-sentence strategic value judgment",
-
-  "trust": {
-    "assessment": "appropriate | too_high | too_low",
-    "recommendation": "maintain | increase | decrease | revoke",
-    "pattern": "What's their angle? Genuine partner or extractive?"
-  },
-
-  "ownerBrief": "2-3 sentences: the strategic takeaway for your owner"
-}
-
-Think like a strategic advisor: protect your owner's interests AND find mutual wins.
+  // Build transcript in unified format
+  const transcript = messages.map(m => ({
+    direction: m.direction,
+    content: m.content
+  }));
+
+  // Map ownerContext (which has .user, .goals, .interests from USER.md) into unified format
+  const unifiedOwnerContext = {
+    agentName: null,
+    ownerName: null,
+    goals: ownerContext?.goals || []
+  };
 
-JSON:`;
+  return buildUnifiedSummaryPrompt({
+    transcript,
+    callerInfo: {
+      name: callerInfo.name || null,
+      owner: callerInfo.owner || null,
+      context: callerInfo.context || null
+    },
+    ownerContext: unifiedOwnerContext
+  });
 }
 
 /**

package/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/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 };