Skip to content

Turn meetings into live agent loops. Record, transcribe, and analyze meetings with real-time AI intelligence — before, during, and after calls.

feat: general purpose feature naming and revamp

Om Gate50032279a741
diff --git a/src/main/db/index.ts b/src/main/db/index.ts
index a751ac1..d0d1d7e 100644
--- a/src/main/db/index.ts
+++ b/src/main/db/index.ts
@@ -83,7 +83,7 @@ export function initDatabase(): ReturnType<typeof drizzle<typeof schema>> {
CREATE TABLE IF NOT EXISTS cue_cards (
id TEXT PRIMARY KEY,
- objection_type TEXT NOT NULL CHECK(objection_type IN ('pricing', 'timing', 'competitor', 'authority', 'security', 'integration', 'not_interested', 'send_info')),
+ objection_type TEXT NOT NULL CHECK(objection_type IN ('open_question', 'decision_point', 'concern', 'risk', 'commitment', 'follow_up', 'information_request', 'pricing', 'timing', 'competitor', 'authority', 'security', 'integration', 'not_interested', 'send_info')),
title TEXT NOT NULL,
talk_tracks TEXT NOT NULL,
follow_up_questions TEXT NOT NULL,
@@ -112,7 +112,7 @@ export function initDatabase(): ReturnType<typeof drizzle<typeof schema>> {
CREATE TABLE IF NOT EXISTS playbooks (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
- type TEXT NOT NULL CHECK(type IN ('MEDDIC', 'Challenger', 'SPIN', 'Custom')),
+ type TEXT NOT NULL CHECK(type IN ('1on1', 'ProjectReview', 'Retrospective', 'Discovery', 'Interview', 'Brainstorm', 'Custom')),
description TEXT,
items TEXT NOT NULL,
is_default INTEGER NOT NULL DEFAULT 0,
@@ -510,6 +510,15 @@ export function updateCueCardTrigger(id: string, data: Partial<schema.CueCardTri
.get();
}
+// Smart Card aliases (new naming convention)
+export const getSmartCardsByType = getCueCardsByType;
+export const getAllSmartCards = getAllCueCards;
+export const createSmartCard = createCueCard;
+export const updateSmartCard = updateCueCard;
+export const createSmartCardTrigger = createCueCardTrigger;
+export const getSmartCardTriggersByRecording = getCueCardTriggersByRecording;
+export const updateSmartCardTrigger = updateCueCardTrigger;
+
export function getPlaybookById(id: string) {
const database = getDatabase();
@@ -824,158 +833,402 @@ function seedDefaultPlaybooks() {
const existing = database
.select()
.from(schema.playbooks)
- .where(eq(schema.playbooks.id, 'playbook-meddic'))
+ .where(eq(schema.playbooks.id, 'template-1on1'))
.get();
if (existing) return;
- const meddicPlaybook: schema.NewPlaybook = {
- id: 'playbook-meddic',
- name: 'MEDDIC Methodology',
- type: 'MEDDIC',
- description: 'A qualification framework focusing on Metrics, Economic Buyer, Decision Criteria, Decision Process, Identify Pain, and Champion.',
+ // 1:1 Check-in Template
+ const oneOnOneTemplate: schema.NewPlaybook = {
+ id: 'template-1on1',
+ name: '1:1 Check-in',
+ type: 'Custom',
+ description: 'A structured template for one-on-one meetings covering updates, goals, blockers, and feedback.',
items: JSON.stringify([
{
- id: 'm-metrics',
- label: 'Metrics',
- description: 'Quantify the business impact and ROI',
- keywords: ['ROI', 'cost savings', 'revenue', 'efficiency', 'metrics', 'numbers', 'measure', 'KPI'],
+ id: 'updates',
+ label: 'Updates & Progress',
+ description: 'Review recent progress and accomplishments',
+ keywords: ['update', 'progress', 'completed', 'finished', 'done', 'accomplished', 'shipped'],
+ suggestedQuestions: [
+ 'What have you been working on since we last met?',
+ 'What are you most proud of recently?',
+ 'Any wins you want to share?'
+ ],
+ detectionPrompt: 'Were updates or recent progress discussed?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'goals',
+ label: 'Goals & Priorities',
+ description: 'Discuss current and upcoming priorities',
+ keywords: ['goal', 'priority', 'focus', 'objective', 'target', 'plan', 'next'],
suggestedQuestions: [
- 'What metrics matter most to your team?',
- 'How do you measure success today?',
- 'What would success look like in numbers?',
- 'What\'s the potential impact on revenue/costs?'
+ 'What are your top priorities for the coming week?',
+ 'Are your current goals still relevant?',
+ 'What do you want to accomplish by our next meeting?'
],
- detectionPrompt: 'Did the conversation discuss quantifiable business metrics, ROI, or measurable outcomes?',
+ detectionPrompt: 'Were goals or priorities discussed?',
status: 'missing',
evidence: []
},
{
- id: 'e-economic-buyer',
- label: 'Economic Buyer',
- description: 'Identify who has budget authority',
- keywords: ['budget', 'decision maker', 'approve', 'CFO', 'procurement', 'sign off', 'authority'],
+ id: 'blockers',
+ label: 'Blockers & Challenges',
+ description: 'Identify obstacles and how to resolve them',
+ keywords: ['blocker', 'challenge', 'stuck', 'problem', 'issue', 'help', 'support', 'difficulty'],
suggestedQuestions: [
- 'Who controls the budget for this initiative?',
- 'Who needs to sign off on this purchase?',
- 'What\'s your procurement process?',
- 'Who else should be involved in this discussion?'
+ 'What\'s blocking your progress?',
+ 'Where do you need help or support?',
+ 'Any challenges I can help with?'
],
- detectionPrompt: 'Was the economic buyer or budget authority identified in the conversation?',
+ detectionPrompt: 'Were blockers or challenges discussed?',
status: 'missing',
evidence: []
},
{
- id: 'd-decision-criteria',
- label: 'Decision Criteria',
- description: 'Understand how they will evaluate solutions',
- keywords: ['criteria', 'requirements', 'must have', 'evaluate', 'compare', 'features', 'needs'],
+ id: 'feedback',
+ label: 'Feedback & Development',
+ description: 'Exchange feedback and discuss growth',
+ keywords: ['feedback', 'improve', 'grow', 'learn', 'development', 'coaching', 'suggestion'],
+ suggestedQuestions: [
+ 'Is there any feedback you\'d like to share?',
+ 'What skills would you like to develop?',
+ 'How can I better support you?'
+ ],
+ detectionPrompt: 'Was feedback or development discussed?',
+ status: 'missing',
+ evidence: []
+ }
+ ]),
+ isDefault: true,
+ };
+
+ database.insert(schema.playbooks).values(oneOnOneTemplate).run();
+
+ // Project Review Template
+ const projectReviewTemplate: schema.NewPlaybook = {
+ id: 'template-project-review',
+ name: 'Project Review',
+ type: 'Custom',
+ description: 'A template for project status meetings covering progress, risks, decisions, and next steps.',
+ items: JSON.stringify([
+ {
+ id: 'status',
+ label: 'Status Overview',
+ description: 'Review overall project status and timeline',
+ keywords: ['status', 'timeline', 'schedule', 'on track', 'behind', 'ahead', 'milestone'],
suggestedQuestions: [
- 'What criteria will you use to make this decision?',
- 'What are your must-have requirements?',
- 'How will you evaluate different options?',
- 'What would make one solution stand out?'
+ 'What\'s the overall project status?',
+ 'Are we on track with the timeline?',
+ 'Any milestones coming up?'
],
- detectionPrompt: 'Were the decision criteria or evaluation requirements discussed?',
+ detectionPrompt: 'Was the project status or timeline discussed?',
status: 'missing',
evidence: []
},
{
- id: 'd-decision-process',
- label: 'Decision Process',
- description: 'Map out the buying process and timeline',
- keywords: ['process', 'timeline', 'steps', 'approval', 'buying', 'next steps', 'when'],
+ id: 'risks',
+ label: 'Risks & Issues',
+ description: 'Identify and discuss project risks',
+ keywords: ['risk', 'issue', 'concern', 'problem', 'blocker', 'delay', 'impact'],
suggestedQuestions: [
- 'What\'s your typical buying process?',
- 'What are the steps to get this approved?',
- 'What\'s your timeline for making a decision?',
- 'Who else needs to be involved?'
+ 'What risks should we be aware of?',
+ 'Any issues that need escalation?',
+ 'What could derail the project?'
],
- detectionPrompt: 'Was the decision-making process or timeline discussed?',
+ detectionPrompt: 'Were project risks or issues discussed?',
status: 'missing',
evidence: []
},
{
- id: 'i-identify-pain',
- label: 'Identify Pain',
- description: 'Uncover the business problems and challenges',
- keywords: ['problem', 'challenge', 'pain', 'issue', 'struggle', 'difficulty', 'frustration', 'bottleneck'],
+ id: 'decisions',
+ label: 'Decisions Needed',
+ description: 'Identify decisions that need to be made',
+ keywords: ['decide', 'decision', 'choose', 'option', 'approve', 'agree', 'consensus'],
suggestedQuestions: [
- 'What challenges are you facing today?',
- 'What\'s the impact of this problem on your business?',
- 'How long has this been an issue?',
- 'What happens if you don\'t solve this?'
+ 'What decisions do we need to make?',
+ 'Who needs to be involved in this decision?',
+ 'What are our options?'
],
- detectionPrompt: 'Were specific pain points, challenges, or problems discussed?',
+ detectionPrompt: 'Were decisions discussed or made?',
status: 'missing',
evidence: []
},
{
- id: 'c-champion',
- label: 'Champion',
- description: 'Identify an internal advocate',
- keywords: ['champion', 'advocate', 'internal', 'support', 'sponsor', 'push', 'drive'],
+ id: 'next-steps',
+ label: 'Next Steps',
+ description: 'Define action items and next steps',
+ keywords: ['next', 'action', 'step', 'task', 'owner', 'deadline', 'follow up'],
suggestedQuestions: [
- 'Who internally would champion this initiative?',
- 'Who else is excited about solving this problem?',
- 'Who can help drive this forward internally?',
- 'Who would benefit most from this solution?'
+ 'What are the next steps?',
+ 'Who owns each action item?',
+ 'When do we need this completed?'
],
- detectionPrompt: 'Was an internal champion or advocate identified?',
+ detectionPrompt: 'Were next steps or action items defined?',
status: 'missing',
evidence: []
}
]),
- isDefault: true,
+ isDefault: false,
+ };
+
+ database.insert(schema.playbooks).values(projectReviewTemplate).run();
+
+ // Retrospective Template
+ const retroTemplate: schema.NewPlaybook = {
+ id: 'template-retrospective',
+ name: 'Retrospective',
+ type: 'Custom',
+ description: 'A template for team retrospectives covering what went well, what could improve, and action items.',
+ items: JSON.stringify([
+ {
+ id: 'went-well',
+ label: 'What Went Well',
+ description: 'Celebrate successes and positive outcomes',
+ keywords: ['well', 'good', 'great', 'success', 'win', 'proud', 'worked', 'positive'],
+ suggestedQuestions: [
+ 'What went well this sprint/period?',
+ 'What should we keep doing?',
+ 'What are we proud of?'
+ ],
+ detectionPrompt: 'Were positive outcomes or successes discussed?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'improve',
+ label: 'What Could Improve',
+ description: 'Identify areas for improvement',
+ keywords: ['improve', 'better', 'challenge', 'difficult', 'issue', 'problem', 'frustrating'],
+ suggestedQuestions: [
+ 'What could we do better?',
+ 'What was frustrating or challenging?',
+ 'What should we stop doing?'
+ ],
+ detectionPrompt: 'Were improvement areas or challenges discussed?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'actions',
+ label: 'Action Items',
+ description: 'Define concrete actions to take',
+ keywords: ['action', 'do', 'change', 'try', 'experiment', 'implement', 'commit'],
+ suggestedQuestions: [
+ 'What specific actions will we take?',
+ 'Who will own each action?',
+ 'How will we measure success?'
+ ],
+ detectionPrompt: 'Were action items or commitments defined?',
+ status: 'missing',
+ evidence: []
+ }
+ ]),
+ isDefault: false,
};
- database.insert(schema.playbooks).values(meddicPlaybook).run();
+ database.insert(schema.playbooks).values(retroTemplate).run();
- const challengerPlaybook: schema.NewPlaybook = {
- id: 'playbook-challenger',
- name: 'Challenger Method',
- type: 'Challenger',
- description: 'A methodology focused on teaching, tailoring, and taking control of the conversation.',
+ // Discovery/Requirements Template
+ const discoveryTemplate: schema.NewPlaybook = {
+ id: 'template-discovery',
+ name: 'Discovery / Requirements',
+ type: 'Custom',
+ description: 'A template for discovery and requirements gathering meetings.',
items: JSON.stringify([
{
- id: 'teach',
- label: 'Teach',
- description: 'Share unique insights and perspectives',
- keywords: ['insight', 'research', 'data', 'trend', 'industry', 'benchmark', 'best practice'],
+ id: 'context',
+ label: 'Context & Background',
+ description: 'Understand the situation and context',
+ keywords: ['context', 'background', 'situation', 'currently', 'today', 'existing', 'history'],
+ suggestedQuestions: [
+ 'Can you give me some background on this?',
+ 'What\'s the current situation?',
+ 'How did we get here?'
+ ],
+ detectionPrompt: 'Was context or background discussed?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'goals',
+ label: 'Goals & Outcomes',
+ description: 'Define desired outcomes and success criteria',
+ keywords: ['goal', 'outcome', 'success', 'achieve', 'want', 'need', 'result', 'objective'],
+ suggestedQuestions: [
+ 'What are you trying to achieve?',
+ 'What does success look like?',
+ 'What are your must-have outcomes?'
+ ],
+ detectionPrompt: 'Were goals or desired outcomes discussed?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'requirements',
+ label: 'Requirements & Constraints',
+ description: 'Gather specific requirements and constraints',
+ keywords: ['requirement', 'need', 'must', 'constraint', 'limitation', 'budget', 'timeline'],
+ suggestedQuestions: [
+ 'What are the key requirements?',
+ 'What constraints do we have?',
+ 'What\'s the timeline and budget?'
+ ],
+ detectionPrompt: 'Were requirements or constraints discussed?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'stakeholders',
+ label: 'Stakeholders',
+ description: 'Identify key stakeholders and decision makers',
+ keywords: ['stakeholder', 'team', 'involved', 'decision', 'approval', 'owner', 'responsible'],
+ suggestedQuestions: [
+ 'Who are the key stakeholders?',
+ 'Who needs to be involved in decisions?',
+ 'Who will be impacted by this?'
+ ],
+ detectionPrompt: 'Were stakeholders or decision makers identified?',
+ status: 'missing',
+ evidence: []
+ }
+ ]),
+ isDefault: false,
+ };
+
+ database.insert(schema.playbooks).values(discoveryTemplate).run();
+
+ // Interview Template
+ const interviewTemplate: schema.NewPlaybook = {
+ id: 'template-interview',
+ name: 'Interview',
+ type: 'Custom',
+ description: 'A template for conducting structured interviews (hiring, user research, etc.).',
+ items: JSON.stringify([
+ {
+ id: 'intro',
+ label: 'Introduction & Context',
+ description: 'Set the stage and build rapport',
+ keywords: ['introduce', 'background', 'tell me about', 'yourself', 'role', 'experience'],
+ suggestedQuestions: [
+ 'Tell me about yourself',
+ 'What brings you here today?',
+ 'Can you walk me through your background?'
+ ],
+ detectionPrompt: 'Was there an introduction or context setting?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'core-questions',
+ label: 'Core Questions',
+ description: 'Cover the main interview topics',
+ keywords: ['example', 'time when', 'describe', 'how did you', 'tell me about', 'situation'],
+ suggestedQuestions: [
+ 'Can you give me an example of...?',
+ 'Tell me about a time when...',
+ 'How did you handle...?'
+ ],
+ detectionPrompt: 'Were core interview questions covered?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'deep-dive',
+ label: 'Follow-up & Deep Dive',
+ description: 'Explore responses in more detail',
+ keywords: ['why', 'how', 'what happened', 'result', 'learn', 'differently', 'outcome'],
+ suggestedQuestions: [
+ 'Why did you approach it that way?',
+ 'What was the result?',
+ 'What would you do differently?'
+ ],
+ detectionPrompt: 'Were follow-up questions asked to go deeper?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'questions',
+ label: 'Candidate Questions',
+ description: 'Allow time for their questions',
+ keywords: ['question', 'ask', 'wonder', 'curious', 'want to know', 'anything else'],
+ suggestedQuestions: [
+ 'What questions do you have for me?',
+ 'Is there anything you\'d like to know?',
+ 'What else would be helpful to understand?'
+ ],
+ detectionPrompt: 'Was time given for their questions?',
+ status: 'missing',
+ evidence: []
+ }
+ ]),
+ isDefault: false,
+ };
+
+ database.insert(schema.playbooks).values(interviewTemplate).run();
+
+ // Brainstorm Template
+ const brainstormTemplate: schema.NewPlaybook = {
+ id: 'template-brainstorm',
+ name: 'Brainstorm / Ideation',
+ type: 'Custom',
+ description: 'A template for brainstorming and ideation sessions.',
+ items: JSON.stringify([
+ {
+ id: 'problem',
+ label: 'Problem Definition',
+ description: 'Clearly define the problem to solve',
+ keywords: ['problem', 'challenge', 'solve', 'issue', 'opportunity', 'goal', 'trying to'],
+ suggestedQuestions: [
+ 'What problem are we trying to solve?',
+ 'Why is this important?',
+ 'What does success look like?'
+ ],
+ detectionPrompt: 'Was the problem clearly defined?',
+ status: 'missing',
+ evidence: []
+ },
+ {
+ id: 'ideas',
+ label: 'Idea Generation',
+ description: 'Generate and capture ideas',
+ keywords: ['idea', 'what if', 'could we', 'maybe', 'option', 'possibility', 'try'],
suggestedQuestions: [
- 'Have you seen the latest research on...?',
- 'What trends are you noticing in your industry?',
- 'How does your approach compare to industry benchmarks?'
+ 'What ideas do we have?',
+ 'What if we tried...?',
+ 'What other options are there?'
],
- detectionPrompt: 'Did you share unique insights or teach the participant something new?',
+ detectionPrompt: 'Were ideas generated and discussed?',
status: 'missing',
evidence: []
},
{
- id: 'tailor',
- label: 'Tailor',
- description: 'Customize the message to the participant',
- keywords: ['specific', 'your situation', 'customize', 'relevant', 'for you', 'in your case'],
+ id: 'evaluation',
+ label: 'Evaluation & Prioritization',
+ description: 'Evaluate and prioritize ideas',
+ keywords: ['prioritize', 'best', 'feasible', 'impact', 'effort', 'vote', 'rank', 'evaluate'],
suggestedQuestions: [
- 'How does this apply to your specific situation?',
- 'What\'s unique about your environment?',
- 'How would this work in your context?'
+ 'Which ideas have the most potential?',
+ 'What\'s feasible given our constraints?',
+ 'How should we prioritize?'
],
- detectionPrompt: 'Was the conversation tailored to the participant\'s specific situation?',
+ detectionPrompt: 'Were ideas evaluated or prioritized?',
status: 'missing',
evidence: []
},
{
- id: 'take-control',
- label: 'Take Control',
- description: 'Guide the conversation and next steps',
- keywords: ['next step', 'recommend', 'suggest', 'should', 'let\'s', 'I propose'],
+ id: 'next-steps',
+ label: 'Next Steps',
+ description: 'Define actions to move forward',
+ keywords: ['next', 'action', 'do', 'try', 'prototype', 'test', 'follow up'],
suggestedQuestions: [
- 'I recommend we...',
- 'The next step should be...',
- 'Let\'s set up...'
+ 'What are our next steps?',
+ 'Who will take this forward?',
+ 'When will we reconvene?'
],
- detectionPrompt: 'Did you take control by guiding next steps and recommendations?',
+ detectionPrompt: 'Were next steps defined?',
status: 'missing',
evidence: []
}
@@ -983,9 +1236,9 @@ function seedDefaultPlaybooks() {
isDefault: false,
};
- database.insert(schema.playbooks).values(challengerPlaybook).run();
+ database.insert(schema.playbooks).values(brainstormTemplate).run();
- logger.info('Seeded default playbooks');
+ logger.info('Seeded default meeting templates');
}
function seedDefaultSettings() {
diff --git a/src/main/db/schema.ts b/src/main/db/schema.ts
index 3c3c124..5b3d9d0 100644
--- a/src/main/db/schema.ts
+++ b/src/main/db/schema.ts
@@ -77,13 +77,18 @@ export const bookmarks = sqliteTable('bookmarks', {
}));
/**
- * Cue Cards
- * Pre-configured objection handling cards with talk tracks
+ * Smart Cards (formerly Cue Cards)
+ * Context-aware prompts with suggested responses
*/
export const cueCards = sqliteTable('cue_cards', {
id: text('id').primaryKey(),
objectionType: text('objection_type', {
- enum: ['pricing', 'timing', 'competitor', 'authority', 'security', 'integration', 'not_interested', 'send_info']
+ enum: [
+ // New trigger categories
+ 'open_question', 'decision_point', 'concern', 'risk', 'commitment', 'follow_up', 'information_request',
+ // Legacy objection types
+ 'pricing', 'timing', 'competitor', 'authority', 'security', 'integration', 'not_interested', 'send_info'
+ ]
}).notNull(),
title: text('title').notNull(),
talkTracks: text('talk_tracks').notNull(), // JSON array of strings
@@ -119,13 +124,13 @@ export const cueCardTriggers = sqliteTable('cue_card_triggers', {
}));
/**
- * Playbooks
- * Meeting methodology definitions (MEDDIC, Challenger, Custom)
+ * Meeting Templates (Agendas)
+ * Pre-defined meeting structures for different meeting types
*/
export const playbooks = sqliteTable('playbooks', {
id: text('id').primaryKey(),
name: text('name').notNull(),
- type: text('type', { enum: ['MEDDIC', 'Challenger', 'SPIN', 'Custom'] }).notNull(),
+ type: text('type', { enum: ['1on1', 'ProjectReview', 'Retrospective', 'Discovery', 'Interview', 'Brainstorm', 'Custom'] }).notNull(),
description: text('description'),
items: text('items').notNull(), // JSON array of PlaybookItem
isDefault: integer('is_default', { mode: 'boolean' }).notNull().default(false),
diff --git a/src/main/server/trpc/procedures/settings.ts b/src/main/server/trpc/procedures/settings.ts
index ed4a983..cf3dfb8 100644
--- a/src/main/server/trpc/procedures/settings.ts
+++ b/src/main/server/trpc/procedures/settings.ts
@@ -27,8 +27,14 @@ import { v4 as uuid } from 'uuid';
// Input Schemas
+// Smart card schema (supports both new trigger categories and legacy objection types)
const cueCardSchema = z.object({
- objectionType: z.enum(['pricing', 'timing', 'competitor', 'authority', 'security', 'integration', 'not_interested', 'send_info']),
+ objectionType: z.enum([
+ // New trigger categories
+ 'open_question', 'decision_point', 'concern', 'risk', 'commitment', 'follow_up', 'information_request',
+ // Legacy objection types for backwards compatibility
+ 'pricing', 'timing', 'competitor', 'authority', 'security', 'integration', 'not_interested', 'send_info'
+ ]),
title: z.string().min(1),
talkTracks: z.array(z.string()),
followUpQuestions: z.array(z.string()),
@@ -48,7 +54,7 @@ const playbookItemSchema = z.object({
const playbookSchema = z.object({
name: z.string().min(1),
- type: z.enum(['MEDDIC', 'Challenger', 'SPIN', 'Custom']),
+ type: z.enum(['1on1', 'ProjectReview', 'Retrospective', 'Discovery', 'Interview', 'Brainstorm', 'Custom']),
description: z.string().optional(),
items: z.array(playbookItemSchema),
});
diff --git a/src/main/services/copilot/index.ts b/src/main/services/copilot/index.ts
index 54b589e..13f5d99 100644
--- a/src/main/services/copilot/index.ts
+++ b/src/main/services/copilot/index.ts
@@ -64,8 +64,16 @@ export {
type NudgeConfig,
} from './nudge-engine.service';
-// Cue card engine
+// Smart card engine (formerly cue card engine)
export {
+ SmartCardEngineService,
+ getSmartCardEngine,
+ resetSmartCardEngine,
+ type TriggerCategory,
+ type SmartCardContent,
+ type SmartCardTriggerData,
+ type TriggerDetectionResult,
+ // Backwards compatibility aliases
CueCardEngineService,
getCueCardEngine,
resetCueCardEngine,
@@ -73,7 +81,7 @@ export {
type CueCardContent,
type CueCardTriggerData,
type ObjectionDetectionResult,
-} from './cue-card-engine.service';
+} from './smart-card-engine.service';
// Playbook tracker
export {
@@ -94,6 +102,7 @@ export {
resetSummaryGenerator,
type CallSummary,
type ActionItem,
+ type Concern,
type Objection,
type Commitment,
type Evidence,
diff --git a/src/main/services/copilot/sales-copilot.service.ts b/src/main/services/copilot/sales-copilot.service.ts
index 2b8b8f3..280eec8 100644
--- a/src/main/services/copilot/sales-copilot.service.ts
+++ b/src/main/services/copilot/sales-copilot.service.ts
@@ -667,7 +667,7 @@ export class MeetingCopilotService extends EventEmitter {
recordingId,
elapsedMs: summaryElapsed,
bullets: summary.bullets.length,
- objections: summary.objections.length,
+ concerns: summary.concerns?.length || 0,
nextSteps: summary.nextSteps.length,
}, 'Summary generation completed');
} catch (error) {
@@ -677,10 +677,12 @@ export class MeetingCopilotService extends EventEmitter {
bullets: [],
customerPain: [],
customerGoals: [],
+ concerns: [],
objections: [],
commitments: [],
nextSteps: [],
keyDecisions: [],
+ openQuestions: [],
riskFlags: ['Summary generation failed: ' + errMsg],
generatedAt: Date.now(),
};
diff --git a/src/main/services/copilot/smart-card-engine.service.ts b/src/main/services/copilot/smart-card-engine.service.ts
new file mode 100644
index 0000000..7af3527
--- /dev/null
+++ b/src/main/services/copilot/smart-card-engine.service.ts
@@ -0,0 +1,514 @@
+/**
+ * Smart Card Engine Service
+ *
+ * Detects meaningful moments in meeting conversations using keyword patterns and LLM
+ * classification. Surfaces context-aware smart cards with suggested responses
+ * and follow-up questions.
+ */
+
+import { v4 as uuid } from 'uuid';
+import { logger } from '../../lib/logger';
+import { getLLMService } from '../llm.service';
+import {
+ getSmartCardsByType,
+ createSmartCardTrigger,
+ updateSmartCardTrigger,
+} from '../../db';
+import type { TranscriptSegmentData } from './transcript-buffer.service';
+
+const log = logger.child({ module: 'smart-card-engine' });
+
+// Types
+
+export type TriggerCategory =
+ | 'open_question'
+ | 'decision_point'
+ | 'concern'
+ | 'risk'
+ | 'commitment'
+ | 'follow_up'
+ | 'information_request'
+ | 'silence';
+
+export interface SmartCardContent {
+ id: string;
+ triggerCategory: TriggerCategory;
+ title: string;
+ suggestedResponses: string[];
+ followUpQuestions: string[];
+ referencePoints?: string[];
+ avoidSaying?: string[];
+ sourceDoc?: string;
+ confidence: number;
+}
+
+export interface SmartCardTriggerData extends SmartCardContent {
+ triggerId: string;
+ triggerText: string;
+ segmentId: string;
+ timestamp: number;
+ status: 'active' | 'pinned' | 'dismissed';
+}
+
+export interface TriggerDetectionResult {
+ detected: boolean;
+ triggerCategory?: TriggerCategory;
+ confidence: number;
+ triggerText?: string;
+}
+
+// Detection Patterns for generic meeting moments
+
+const DETECTION_PATTERNS: Record<TriggerCategory, RegExp[]> = {
+ open_question: [
+ /\b(what do you think|how would|could you explain|can you clarify)\b/i,
+ /\b(what's your.*opinion|how do you see|what are your thoughts)\b/i,
+ /\?\s*$/, // Ends with question mark
+ /\b(wondering|curious|question about)\b/i,
+ ],
+ decision_point: [
+ /\b(should we|do we want to|need to decide|decision|which option)\b/i,
+ /\b(let's.*agree|we need to.*choose|what.*approach)\b/i,
+ /\b(go with|move forward with|proceed with)\b/i,
+ /\b(consensus|vote|settle on)\b/i,
+ ],
+ concern: [
+ /\b(concerned|worried|hesitant|not sure about|skeptical)\b/i,
+ /\b(issue|problem|challenge|difficult|hard to)\b/i,
+ /\b(but|however|although|on the other hand)\b/i,
+ /\b(risky|uncomfortable|unsure)\b/i,
+ ],
+ risk: [
+ /\b(risk|blocker|dependency|deadline|delay)\b/i,
+ /\b(might not|could fail|at risk|blocking)\b/i,
+ /\b(scope creep|budget.*issue|timeline.*concern)\b/i,
+ /\b(won't be able|can't complete|running out of)\b/i,
+ ],
+ commitment: [
+ /\b(I'll|I will|we'll|we will|let me|I can)\b/i,
+ /\b(take.*action|follow up|send.*over|get back)\b/i,
+ /\b(by.*date|by.*end of|before.*meeting)\b/i,
+ /\b(promise|commit|agree to|action item)\b/i,
+ ],
+ follow_up: [
+ /\b(circle back|revisit|follow up|next meeting)\b/i,
+ /\b(table.*for now|park.*for later|come back to)\b/i,
+ /\b(schedule.*another|set up.*time|book.*slot)\b/i,
+ /\b(needs more.*discussion|discuss.*further)\b/i,
+ ],
+ information_request: [
+ /\b(send.*info|share.*document|forward.*details)\b/i,
+ /\b(need.*data|look up|find out|research)\b/i,
+ /\b(where can I|how do I|documentation)\b/i,
+ /\b(link to|reference|resource)\b/i,
+ ],
+ silence: [
+ // Silence is detected via timing, not text patterns
+ ],
+};
+
+// Smart Card Engine Service
+
+export class SmartCardEngineService {
+ private recentTriggers: Map<string, number> = new Map(); // triggerCategory -> timestamp
+ private readonly TRIGGER_COOLDOWN = 60000; // 1 minute between same type
+
+ constructor() {}
+
+ /**
+ * Detect trigger in a segment (fast, pattern-based)
+ */
+ detectTriggerFast(segment: TranscriptSegmentData): TriggerDetectionResult {
+ const text = segment.text.toLowerCase();
+
+ for (const [category, patterns] of Object.entries(DETECTION_PATTERNS)) {
+ if (category === 'silence') continue; // Silence is handled separately
+
+ for (const pattern of patterns) {
+ if (pattern.test(text)) {
+ // Check cooldown
+ const lastTrigger = this.recentTriggers.get(category);
+ if (lastTrigger && Date.now() - lastTrigger < this.TRIGGER_COOLDOWN) {
+ continue;
+ }
+
+ return {
+ detected: true,
+ triggerCategory: category as TriggerCategory,
+ confidence: 0.7,
+ triggerText: segment.text,
+ };
+ }
+ }
+ }
+
+ return { detected: false, confidence: 0 };
+ }
+
+ /**
+ * Detect trigger using LLM for nuanced detection
+ */
+ async detectTriggerWithLLM(
+ segment: TranscriptSegmentData,
+ context: string
+ ): Promise<TriggerDetectionResult> {
+ const llm = getLLMService();
+
+ const prompt = `Analyze this statement from a meeting for meaningful moments that could benefit from a smart prompt.
+
+Context (recent conversation):
+${context}
+
+Current statement from ${segment.channel === 'me' ? 'You' : 'Other Participant'}: "${segment.text}"
+
+Trigger categories:
+- open_question: An unanswered question that needs addressing
+- decision_point: A moment requiring a decision or agreement
+- concern: Hesitation, skepticism, or worry being expressed
+- risk: A potential blocker, risk, or issue being raised
+- commitment: Someone making or suggesting a commitment/action item
+- follow_up: Something that needs to be revisited or followed up on
+- information_request: A request for information, documents, or data
+
+Respond with JSON:
+{
+ "detected": true/false,
+ "trigger_category": "open_question" | "decision_point" | "concern" | "risk" | "commitment" | "follow_up" | "information_request" | null,
+ "confidence": 0.0-1.0,
+ "reasoning": "brief explanation"
+}`;
+
+ try {
+ const response = await llm.completeJSON<{
+ detected: boolean;
+ trigger_category: TriggerCategory | null;
+ confidence: number;
+ reasoning: string;
+ }>(prompt, 'You are a meeting analysis expert. Return valid JSON only.');
+
+ if (response.success && response.data) {
+ if (response.data.detected && response.data.trigger_category && response.data.confidence > 0.6) {
+ return {
+ detected: true,
+ triggerCategory: response.data.trigger_category,
+ confidence: response.data.confidence,
+ triggerText: segment.text,
+ };
+ }
+ }
+ } catch (error) {
+ log.warn({ error }, 'LLM trigger detection failed');
+ }
+
+ return { detected: false, confidence: 0 };
+ }
+
+ /**
+ * Retrieve smart card for a trigger category
+ */
+ async getSmartCard(
+ triggerCategory: TriggerCategory,
+ triggerText: string,
+ context: string
+ ): Promise<SmartCardContent | null> {
+ // Get smart cards from database (uses old schema with objectionType/talkTracks)
+ const cards = getSmartCardsByType(triggerCategory);
+
+ if (cards.length === 0) {
+ // Generate a smart card using LLM
+ return this.generateSmartCard(triggerCategory, triggerText, context);
+ }
+
+ // If multiple cards, use LLM to pick the best one
+ if (cards.length > 1) {
+ return this.selectBestSmartCard(cards.map(this.mapDbCardToSmartCard.bind(this)), triggerText, context);
+ }
+
+ // Single card - map from DB schema to SmartCardContent
+ return this.mapDbCardToSmartCard(cards[0]);
+ }
+
+ /**
+ * Map database card (old schema) to SmartCardContent (new schema)
+ */
+ private mapDbCardToSmartCard(card: {
+ id: string;
+ objectionType: string;
+ title: string;
+ talkTracks: string;
+ followUpQuestions: string;
+ proofPoints?: string | null;
+ avoidSaying?: string | null;
+ sourceDoc?: string | null;
+ }): SmartCardContent {
+ return {
+ id: card.id,
+ triggerCategory: card.objectionType as TriggerCategory,
+ title: card.title,
+ suggestedResponses: JSON.parse(card.talkTracks),
+ followUpQuestions: JSON.parse(card.followUpQuestions),
+ referencePoints: card.proofPoints ? JSON.parse(card.proofPoints) : undefined,
+ avoidSaying: card.avoidSaying ? JSON.parse(card.avoidSaying) : undefined,
+ sourceDoc: card.sourceDoc || undefined,
+ confidence: 0.9,
+ };
+ }
+
+ /**
+ * Process a segment and potentially return a smart card trigger
+ */
+ async processSegment(
+ segment: TranscriptSegmentData,
+ context: string,
+ recordingId: number,
+ useLLM: boolean = false
+ ): Promise<SmartCardTriggerData | null> {
+ // Fast detection first
+ let detection = this.detectTriggerFast(segment);
+
+ // If not detected and LLM is enabled, try LLM
+ if (!detection.detected && useLLM) {
+ detection = await this.detectTriggerWithLLM(segment, context);
+ }
+
+ if (!detection.detected || !detection.triggerCategory) {
+ return null;
+ }
+
+ // Update cooldown
+ this.recentTriggers.set(detection.triggerCategory, Date.now());
+
+ // Get smart card
+ const smartCard = await this.getSmartCard(
+ detection.triggerCategory,
+ detection.triggerText || segment.text,
+ context
+ );
+
+ if (!smartCard) {
+ return null;
+ }
+
+ // Create trigger record (using old schema field names for DB compatibility)
+ const triggerId = uuid();
+ try {
+ createSmartCardTrigger({
+ id: triggerId,
+ recordingId,
+ segmentId: segment.id,
+ cueCardId: smartCard.id, // Old schema name
+ objectionType: detection.triggerCategory, // Old schema name
+ triggerText: segment.text,
+ confidence: smartCard.confidence,
+ status: 'active',
+ timestamp: segment.startTime,
+ });
+ } catch (error) {
+ log.error({ error }, 'Failed to save smart card trigger');
+ }
+
+ return {
+ ...smartCard,
+ triggerId,
+ triggerText: segment.text,
+ segmentId: segment.id,
+ timestamp: segment.startTime,
+ status: 'active',
+ };
+ }
+
+ /**
+ * Generate a smart card using LLM
+ */
+ private async generateSmartCard(
+ triggerCategory: TriggerCategory,
+ triggerText: string,
+ context: string
+ ): Promise<SmartCardContent> {
+ const llm = getLLMService();
+
+ const categoryDescriptions: Record<TriggerCategory, string> = {
+ open_question: 'An unanswered question',
+ decision_point: 'A decision that needs to be made',
+ concern: 'A concern or hesitation being raised',
+ risk: 'A potential risk or blocker',
+ commitment: 'A commitment or action item',
+ follow_up: 'Something to follow up on',
+ information_request: 'A request for information',
+ silence: 'An awkward silence or pause',
+ };
+
+ const prompt = `Generate a smart card to help respond to this meeting moment.
+
+Trigger type: ${triggerCategory} - ${categoryDescriptions[triggerCategory]}
+Statement: "${triggerText}"
+
+Context:
+${context}
+
+Respond with JSON:
+{
+ "title": "Brief title for this card",
+ "suggested_responses": ["3-5 suggested responses or talking points"],
+ "follow_up_questions": ["2-4 helpful questions to ask"],
+ "reference_points": ["1-2 key points to keep in mind"],
+ "avoid_saying": ["1-2 things to avoid"]
+}`;
+
+ try {
+ const response = await llm.completeJSON<{
+ title: string;
+ suggested_responses: string[];
+ follow_up_questions: string[];
+ reference_points?: string[];
+ avoid_saying?: string[];
+ }>(prompt, 'You are a meeting facilitation expert. Return valid JSON only.');
+
+ if (response.success && response.data) {
+ return {
+ id: `generated-${uuid()}`,
+ triggerCategory,
+ title: response.data.title || `Responding to ${triggerCategory.replace('_', ' ')}`,
+ suggestedResponses: response.data.suggested_responses || [],
+ followUpQuestions: response.data.follow_up_questions || [],
+ referencePoints: response.data.reference_points,
+ avoidSaying: response.data.avoid_saying,
+ confidence: 0.6,
+ };
+ }
+ } catch (error) {
+ log.warn({ error }, 'Failed to generate smart card');
+ }
+
+ // Fallback
+ return {
+ id: `fallback-${uuid()}`,
+ triggerCategory,
+ title: `${triggerCategory.replace('_', ' ')} detected`,
+ suggestedResponses: ['Acknowledge the point', 'Ask for clarification if needed'],
+ followUpQuestions: ['Can you tell me more about that?', 'What would help here?'],
+ confidence: 0.3,
+ };
+ }
+
+ /**
+ * Select the best smart card from multiple options
+ */
+ private async selectBestSmartCard(
+ cards: SmartCardContent[],
+ triggerText: string,
+ context: string
+ ): Promise<SmartCardContent> {
+ const llm = getLLMService();
+
+ const cardsContext = cards.map((card, idx) => {
+ const responses = card.suggestedResponses;
+ return `Card ${idx + 1} (${card.id}):\nTitle: ${card.title}\nResponses: ${responses.slice(0, 2).join('; ')}`;
+ }).join('\n\n');
+
+ const prompt = `Select the most relevant smart card for this meeting moment.
+
+Statement: "${triggerText}"
+
+Context:
+${context}
+
+Available smart cards:
+${cardsContext}
+
+Respond with JSON:
+{
+ "selected_index": 0-${cards.length - 1},
+ "confidence": 0.0-1.0,
+ "reasoning": "why this card is best"
+}`;
+
+ try {
+ const response = await llm.completeJSON<{
+ selected_index: number;
+ confidence: number;
+ reasoning: string;
+ }>(prompt, 'You are a meeting facilitation expert. Return valid JSON only.');
+
+ if (response.success && response.data) {
+ const selectedIndex = Math.max(0, Math.min(response.data.selected_index, cards.length - 1));
+ const selected = cards[selectedIndex];
+
+ return {
+ ...selected,
+ confidence: response.data.confidence,
+ };
+ }
+ } catch (error) {
+ log.warn({ error }, 'Failed to select best smart card');
+ }
+
+ // Fallback to first card
+ return {
+ ...cards[0],
+ confidence: 0.7,
+ };
+ }
+
+ /**
+ * Update smart card trigger status
+ */
+ updateTriggerStatus(triggerId: string, status: 'active' | 'pinned' | 'dismissed'): void {
+ try {
+ updateSmartCardTrigger(triggerId, { status });
+ } catch (error) {
+ log.error({ error, triggerId, status }, 'Failed to update trigger status');
+ }
+ }
+
+ /**
+ * Submit feedback for a smart card trigger
+ */
+ submitFeedback(triggerId: string, feedback: 'helpful' | 'wrong' | 'irrelevant'): void {
+ try {
+ updateSmartCardTrigger(triggerId, { feedback });
+ log.info({ triggerId, feedback }, 'Smart card feedback submitted');
+ } catch (error) {
+ log.error({ error, triggerId, feedback }, 'Failed to submit feedback');
+ }
+ }
+
+ /**
+ * Reset cooldowns
+ */
+ reset(): void {
+ this.recentTriggers.clear();
+ }
+}
+
+// Singleton Instance
+
+let instance: SmartCardEngineService | null = null;
+
+export function getSmartCardEngine(): SmartCardEngineService {
+ if (!instance) {
+ instance = new SmartCardEngineService();
+ }
+ return instance;
+}
+
+export function resetSmartCardEngine(): void {
+ if (instance) {
+ instance.reset();
+ }
+ instance = null;
+}
+
+// Backwards compatibility aliases
+export {
+ SmartCardEngineService as CueCardEngineService,
+ getSmartCardEngine as getCueCardEngine,
+ resetSmartCardEngine as resetCueCardEngine,
+};
+
+export type ObjectionType = TriggerCategory;
+export type CueCardContent = SmartCardContent;
+export type CueCardTriggerData = SmartCardTriggerData;
+export type ObjectionDetectionResult = TriggerDetectionResult;
+
+export default SmartCardEngineService;
diff --git a/src/main/services/copilot/summary-generator.service.ts b/src/main/services/copilot/summary-generator.service.ts
index 45a12c8..b70e745 100644
--- a/src/main/services/copilot/summary-generator.service.ts
+++ b/src/main/services/copilot/summary-generator.service.ts
@@ -1,8 +1,8 @@
/**
* Summary Generator Service
*
- * Fast extraction of key call outcomes using parallel LLM calls.
- * Generates summary bullets, pain points, objections, commitments,
+ * Fast extraction of key meeting outcomes using parallel LLM calls.
+ * Generates summary bullets, pain points, concerns, commitments,
* and next steps with evidence linking to transcript timestamps.
*/
@@ -31,7 +31,7 @@ export interface ActionItem {
evidence: Evidence[];
}
-export interface Objection {
+export interface Concern {
type: string;
text: string;
response?: string;
@@ -39,6 +39,9 @@ export interface Objection {
timestamp: number;
}
+// Backwards compatibility alias
+export type Objection = Concern;
+
export interface Commitment {
who: 'me' | 'them';
commitment: string;
@@ -48,14 +51,17 @@ export interface Commitment {
export interface CallSummary {
bullets: string[]; // 5-10 bullet summary
- customerPain: string[]; // Pain points mentioned
- customerGoals: string[]; // Goals/objectives mentioned
- objections: Objection[];
+ customerPain: string[]; // Challenges discussed (field name kept for backwards compat)
+ customerGoals: string[]; // Objectives identified (field name kept for backwards compat)
+ concerns: Concern[]; // Concerns raised during the meeting
commitments: Commitment[];
nextSteps: ActionItem[];
keyDecisions: string[];
+ openQuestions: string[]; // Unresolved questions
riskFlags: string[];
generatedAt: number;
+ // Backwards compatibility aliases
+ objections?: Concern[];
}
export interface FullCallReport {
@@ -86,28 +92,31 @@ export class SummaryGeneratorService {
// Run extractions in parallel for speed with error handling
let bullets: string[] = [];
let painAndGoals: { pain: string[]; goals: string[] } = { pain: [], goals: [] };
- let objections: Objection[] = [];
+ let concerns: Concern[] = [];
let commitments: Commitment[] = [];
let nextSteps: ActionItem[] = [];
let decisions: string[] = [];
+ let openQuestions: string[] = [];
try {
const results = await Promise.allSettled([
this.extractBullets(finalSegments),
this.extractPainAndGoals(finalSegments),
- this.extractObjections(finalSegments),
+ this.extractConcerns(finalSegments),
this.extractCommitments(finalSegments),
this.extractNextSteps(finalSegments),
this.extractDecisions(finalSegments),
+ this.extractOpenQuestions(finalSegments),
]);
// Process results, using defaults for any that failed
bullets = results[0].status === 'fulfilled' ? results[0].value : [];
painAndGoals = results[1].status === 'fulfilled' ? results[1].value : { pain: [], goals: [] };
- objections = results[2].status === 'fulfilled' ? results[2].value : [];
+ concerns = results[2].status === 'fulfilled' ? results[2].value : [];
commitments = results[3].status === 'fulfilled' ? results[3].value : [];
nextSteps = results[4].status === 'fulfilled' ? results[4].value : [];
decisions = results[5].status === 'fulfilled' ? results[5].value : [];
+ openQuestions = results[6].status === 'fulfilled' ? results[6].value : [];
// Log any failures
const failures = results.filter(r => r.status === 'rejected');
@@ -125,26 +134,29 @@ export class SummaryGeneratorService {
bullets: bullets.length,
painPoints: painAndGoals.pain.length,
goals: painAndGoals.goals.length,
- objections: objections.length,
+ concerns: concerns.length,
commitments: commitments.length,
nextSteps: nextSteps.length,
decisions: decisions.length,
+ openQuestions: openQuestions.length,
}, 'Summary extraction complete');
} catch (error) {
log.error({ error }, 'Summary generation failed completely');
}
// Extract risk flags from various sources
- const riskFlags = this.identifyRisks(objections, painAndGoals.pain, commitments);
+ const riskFlags = this.identifyRisks(concerns, painAndGoals.pain, commitments);
return {
bullets,
customerPain: painAndGoals.pain,
customerGoals: painAndGoals.goals,
- objections,
+ concerns,
+ objections: concerns, // Backwards compatibility
commitments,
nextSteps,
keyDecisions: decisions,
+ openQuestions,
riskFlags,
generatedAt: Date.now(),
};
@@ -207,25 +219,25 @@ Respond with JSON:
}
/**
- * Extract pain points and goals
+ * Extract challenges and objectives discussed
*/
private async extractPainAndGoals(
segments: TranscriptSegmentData[]
): Promise<{ pain: string[]; goals: string[] }> {
- // Focus on customer statements
+ // Focus on other participant statements
const themSegments = segments.filter(s => s.channel === 'them');
const transcript = this.formatTranscript(themSegments);
const llm = getLLMService();
- const prompt = `Extract the participant's pain points and goals from this meeting.
+ const prompt = `Extract challenges discussed and objectives/goals mentioned from this meeting.
-Customer statements:
+Participant statements:
${transcript}
Respond with JSON:
{
- "pain_points": ["pain 1", "pain 2"],
- "goals": ["goal 1", "goal 2"]
+ "pain_points": ["challenge 1", "challenge 2"],
+ "goals": ["objective 1", "objective 2"]
}`;
try {
@@ -248,23 +260,23 @@ Respond with JSON:
}
/**
- * Extract objections and responses
+ * Extract concerns raised and how they were addressed
*/
- private async extractObjections(segments: TranscriptSegmentData[]): Promise<Objection[]> {
+ private async extractConcerns(segments: TranscriptSegmentData[]): Promise<Concern[]> {
const transcript = this.formatFullTranscript(segments);
const llm = getLLMService();
- const prompt = `Extract objections or concerns raised and how they were addressed.
+ const prompt = `Extract concerns, hesitations, or pushback raised during this meeting and how they were addressed.
${transcript}
Respond with JSON:
{
- "objections": [
+ "concerns": [
{
- "type": "pricing|timing|competitor|authority|other",
- "text": "what customer said",
- "response": "how rep responded (if captured)",
+ "type": "budget|timeline|risk|scope|resource|technical|other",
+ "text": "what was said",
+ "response": "how it was addressed (if captured)",
"resolved": true/false,
"timestamp": seconds from start
}
@@ -273,20 +285,52 @@ Respond with JSON:
try {
const response = await llm.completeJSON<{
- objections: Array<{
+ concerns: Array<{
type: string;
text: string;
response?: string;
resolved: boolean;
timestamp: number;
}>;
- }>(prompt, 'You are a meeting objection analysis expert. Return valid JSON only.');
+ }>(prompt, 'You are a meeting analysis expert. Return valid JSON only.');
+
+ if (response.success && response.data) {
+ return response.data.concerns || [];
+ }
+ } catch (error) {
+ log.warn({ error }, 'Concern extraction failed');
+ }
+
+ return [];
+ }
+
+ /**
+ * Extract open questions that weren't fully answered
+ */
+ private async extractOpenQuestions(segments: TranscriptSegmentData[]): Promise<string[]> {
+ const transcript = this.formatFullTranscript(segments);
+ const llm = getLLMService();
+
+ const prompt = `Identify questions that were asked during this meeting but weren't fully answered or need follow-up.
+
+${transcript}
+
+Respond with JSON:
+{
+ "open_questions": ["question 1", "question 2"]
+}`;
+
+ try {
+ const response = await llm.completeJSON<{ open_questions: string[] }>(
+ prompt,
+ 'You are a meeting analysis expert. Return valid JSON only.'
+ );
if (response.success && response.data) {
- return response.data.objections || [];
+ return response.data.open_questions || [];
}
} catch (error) {
- log.warn({ error }, 'Objection extraction failed');
+ log.warn({ error }, 'Open questions extraction failed');
}
return [];
@@ -421,26 +465,26 @@ Respond with JSON:
* Identify risk flags from extracted data
*/
private identifyRisks(
- objections: Objection[],
+ concerns: Concern[],
painPoints: string[],
commitments: Commitment[]
): string[] {
const risks: string[] = [];
- // Unresolved objections
- const unresolvedObjections = objections.filter(o => !o.resolved);
- if (unresolvedObjections.length > 0) {
- risks.push(`${unresolvedObjections.length} unresolved objection(s)`);
+ // Unresolved concerns
+ const unresolvedConcerns = concerns.filter(c => !c.resolved);
+ if (unresolvedConcerns.length > 0) {
+ risks.push(`${unresolvedConcerns.length} unresolved concern(s)`);
}
- // Authority objection (decision maker not identified)
- if (objections.some(o => o.type === 'authority')) {
- risks.push('Decision maker may not be identified');
+ // Risk-related concerns
+ if (concerns.some(c => c.type === 'risk' || c.type === 'blocker')) {
+ risks.push('Risk or blocker identified');
}
// No pain points identified
if (painPoints.length === 0) {
- risks.push('Pain points not clearly identified');
+ risks.push('Key challenges not clearly identified');
}
// No commitments from other participant
@@ -487,10 +531,12 @@ Respond with JSON:
bullets: [],
customerPain: [],
customerGoals: [],
- objections: [],
+ concerns: [],
+ objections: [], // Backwards compatibility
commitments: [],
nextSteps: [],
keyDecisions: [],
+ openQuestions: [],
riskFlags: [],
generatedAt: Date.now(),
};
diff --git a/src/renderer/components/copilot/CallSummaryView.tsx b/src/renderer/components/copilot/CallSummaryView.tsx
index 2879485..c648e7f 100644
--- a/src/renderer/components/copilot/CallSummaryView.tsx
+++ b/src/renderer/components/copilot/CallSummaryView.tsx
@@ -1,10 +1,10 @@
/**
- * Call Summary View Component
+ * Meeting Summary View Component
*
- * Displays post-call AI-generated summary with:
+ * Displays post-meeting AI-generated summary with:
* - Summary bullets
- * - Customer pain points and goals
- * - Objections and responses
+ * - Challenges and objectives identified
+ * - Concerns raised and responses
* - Commitments
* - Next steps / action items
* - Risk flags
@@ -93,14 +93,14 @@ function BulletList({ items, icon }: { items: string[]; icon?: React.ReactNode }
);
}
-function ObjectionsList({ objections }: { objections: CopilotCallSummary['objections'] }) {
- if (!objections || objections.length === 0) {
- return <p className="text-sm text-muted-foreground italic">No objections raised</p>;
+function ConcernsList({ concerns }: { concerns: CopilotCallSummary['objections'] }) {
+ if (!concerns || concerns.length === 0) {
+ return <p className="text-sm text-muted-foreground italic">No concerns raised</p>;
}
return (
<div className="space-y-2">
- {objections.map((obj, i) => (
+ {concerns.map((obj, i) => (
<div key={i} className="p-2 bg-muted/50 rounded-lg">
<div className="flex items-center gap-2 mb-1">
<Badge variant="outline" className="text-xs capitalize">
@@ -138,7 +138,7 @@ function CommitmentsList({ commitments }: { commitments: CopilotCallSummary['com
{commitments.map((com, i) => (
<div key={i} className="flex items-start gap-2 p-2 bg-muted/50 rounded-lg">
<Badge variant={com.who === 'me' ? 'default' : 'secondary'} className="text-xs shrink-0">
- {com.who === 'me' ? 'You' : 'Customer'}
+ {com.who === 'me' ? 'You' : 'Them'}
</Badge>
<p className="text-sm">{com.commitment}</p>
</div>
@@ -172,7 +172,7 @@ function NextStepsList({ nextSteps }: { nextSteps: CopilotCallSummary['nextSteps
<p className="text-sm">{step.action}</p>
<div className="flex items-center gap-2 mt-1">
<Badge variant="outline" className="text-xs">
- {step.owner === 'me' ? 'You' : step.owner === 'them' ? 'Customer' : 'Both'}
+ {step.owner === 'me' ? 'You' : step.owner === 'them' ? 'Them' : 'Both'}
</Badge>
<Badge className={cn("text-xs", getPriorityColor(step.priority))}>
{step.priority}
@@ -213,7 +213,7 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
<CardHeader>
<CardTitle className="text-lg flex items-center gap-2">
<FileText className="h-5 w-5" />
- Call Summary
+ Meeting Summary
</CardTitle>
</CardHeader>
<CardContent>
@@ -233,12 +233,12 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
const copyToClipboard = () => {
const text = [
- '# Call Summary',
+ '# Meeting Summary',
'',
'## Key Points',
...summary.bullets.map(b => `- ${b}`),
'',
- '## Customer Pain Points',
+ '## Challenges Discussed',
...summary.customerPain.map(p => `- ${p}`),
'',
'## Next Steps',
@@ -250,7 +250,7 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
setTimeout(() => setCopied(false), 2000);
};
- const unresolvedObjections = summary.objections?.filter(o => !o.resolved).length || 0;
+ const unresolvedConcerns = summary.objections?.filter(o => !o.resolved).length || 0;
return (
<Card className={cn("", className)}>
@@ -258,7 +258,7 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
<div className="flex items-center justify-between">
<CardTitle className="text-lg flex items-center gap-2">
<FileText className="h-5 w-5" />
- Call Summary
+ Meeting Summary
</CardTitle>
<div className="flex items-center gap-2">
<Badge variant="outline" className="text-xs">
@@ -301,9 +301,9 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
<BulletList items={summary.bullets} />
</Section>
- {/* Customer Pain & Goals */}
+ {/* Challenges & Objectives */}
<Section
- title="Customer Pain Points"
+ title="Challenges Discussed"
icon={<Target className="h-4 w-4" />}
count={summary.customerPain?.length}
>
@@ -312,7 +312,7 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
{summary.customerGoals && summary.customerGoals.length > 0 && (
<Section
- title="Customer Goals"
+ title="Objectives Identified"
icon={<Lightbulb className="h-4 w-4" />}
count={summary.customerGoals.length}
defaultOpen={false}
@@ -321,14 +321,14 @@ export function CallSummaryView({ className, summary: propSummary, playbook: pro
</Section>
)}
- {/* Objections */}
+ {/* Concerns */}
<Section
- title="Objections"
+ title="Concerns Raised"
icon={<MessageSquare className="h-4 w-4" />}
count={summary.objections?.length}
- badge={unresolvedObjections > 0 ? { text: `${unresolvedObjections} open`, variant: 'destructive' } : undefined}
+ badge={unresolvedConcerns > 0 ? { text: `${unresolvedConcerns} open`, variant: 'destructive' } : undefined}
>
- <ObjectionsList objections={summary.objections} />
+ <ConcernsList concerns={summary.objections} />
</Section>
{/* Commitments */}
diff --git a/src/renderer/components/copilot/CueCardOverlay.tsx b/src/renderer/components/copilot/CueCardOverlay.tsx
index e3f8031..e2e2548 100644
--- a/src/renderer/components/copilot/CueCardOverlay.tsx
+++ b/src/renderer/components/copilot/CueCardOverlay.tsx
@@ -43,54 +43,66 @@ interface CueCardItemProps {
function CueCardItem({ cueCard, isPinned, onDismiss, onPin, onFeedback }: CueCardItemProps) {
const [showFeedback, setShowFeedback] = useState(false);
- const getObjectionGradient = (type: string) => {
+ const getTriggerGradient = (type: string) => {
switch (type) {
- case 'pricing':
- return 'from-green-50 to-emerald-50 dark:from-green-950/30 dark:to-emerald-950/30';
- case 'timing':
- return 'from-amber-50 to-orange-50 dark:from-amber-950/30 dark:to-orange-950/30';
- case 'competitor':
- return 'from-purple-50 to-violet-50 dark:from-purple-950/30 dark:to-violet-950/30';
- case 'authority':
+ case 'open_question':
return 'from-blue-50 to-indigo-50 dark:from-blue-950/30 dark:to-indigo-950/30';
- case 'security':
+ case 'decision_point':
+ return 'from-purple-50 to-violet-50 dark:from-purple-950/30 dark:to-violet-950/30';
+ case 'concern':
+ return 'from-amber-50 to-orange-50 dark:from-amber-950/30 dark:to-orange-950/30';
+ case 'risk':
return 'from-red-50 to-rose-50 dark:from-red-950/30 dark:to-rose-950/30';
- case 'integration':
+ case 'commitment':
+ return 'from-green-50 to-emerald-50 dark:from-green-950/30 dark:to-emerald-950/30';
+ case 'follow_up':
return 'from-cyan-50 to-teal-50 dark:from-cyan-950/30 dark:to-teal-950/30';
+ case 'information_request':
+ return 'from-indigo-50 to-blue-50 dark:from-indigo-950/30 dark:to-blue-950/30';
default:
return 'from-slate-50 to-gray-50 dark:from-slate-950/30 dark:to-gray-950/30';
}
};
- const getObjectionColor = (type: string) => {
+ const getTriggerColor = (type: string) => {
switch (type) {
- case 'pricing':
- return 'bg-green-500 text-white';
- case 'timing':
- return 'bg-amber-500 text-white';
- case 'competitor':
- return 'bg-purple-500 text-white';
- case 'authority':
+ case 'open_question':
return 'bg-blue-500 text-white';
- case 'security':
+ case 'decision_point':
+ return 'bg-purple-500 text-white';
+ case 'concern':
+ return 'bg-amber-500 text-white';
+ case 'risk':
return 'bg-red-500 text-white';
- case 'integration':
+ case 'commitment':
+ return 'bg-green-500 text-white';
+ case 'follow_up':
return 'bg-cyan-500 text-white';
+ case 'information_request':
+ return 'bg-indigo-500 text-white';
default:
return 'bg-slate-500 text-white';
}
};
+ const formatTriggerLabel = (type: string) => {
+ return type.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+ };
+
+ // Backwards compatibility aliases
+ const getObjectionGradient = getTriggerGradient;
+ const getObjectionColor = getTriggerColor;
+
return (
<Card className="overflow-hidden shadow-lg border-2 animate-in slide-in-from-right duration-300">
{/* Header with gradient */}
<CardHeader
- className={cn('border-b p-4 bg-gradient-to-r', getObjectionGradient(cueCard.objectionType))}
+ className={cn('border-b p-4 bg-gradient-to-r', getTriggerGradient(cueCard.objectionType))}
>
<div className="flex items-start justify-between mb-2">
<div className="flex-1">
- <Badge className={cn('mb-2 text-xs', getObjectionColor(cueCard.objectionType))}>
- {cueCard.objectionType}
+ <Badge className={cn('mb-2 text-xs', getTriggerColor(cueCard.objectionType))}>
+ {formatTriggerLabel(cueCard.objectionType)}
</Badge>
<h3 className="font-semibold text-base leading-tight">{cueCard.title}</h3>
</div>
@@ -276,7 +288,7 @@ export function CueCardOverlay({ className, maxCards = 2 }: CueCardOverlayProps)
<Lightbulb className="h-8 w-8 text-slate-300 dark:text-slate-600 mx-auto mb-2" />
<p className="text-sm text-slate-500 dark:text-slate-400">
{isCallActive
- ? 'Cue cards will appear when objections are detected'
+ ? 'Smart cards will appear when relevant moments are detected'
: 'Start recording to see live assistance'}
</p>
</div>
diff --git a/src/renderer/components/copilot/MetricsPanel.tsx b/src/renderer/components/copilot/MetricsPanel.tsx
index e762d73..d28c102 100644
--- a/src/renderer/components/copilot/MetricsPanel.tsx
+++ b/src/renderer/components/copilot/MetricsPanel.tsx
@@ -66,7 +66,7 @@ function TalkRatioBar({ meRatio, themRatio }: TalkRatioBarProps) {
{!isBalanced && meRatio > 0.65 && (
<p className="text-xs text-amber-600 flex items-center gap-1">
<AlertTriangle className="h-3 w-3" />
- Consider letting the customer speak more
+ Consider letting them speak more
</p>
)}
</div>
diff --git a/src/renderer/components/copilot/PlaybookPanel.tsx b/src/renderer/components/copilot/PlaybookPanel.tsx
index b21e0d4..4c44ffa 100644
--- a/src/renderer/components/copilot/PlaybookPanel.tsx
+++ b/src/renderer/components/copilot/PlaybookPanel.tsx
@@ -1,8 +1,8 @@
/**
* Playbook Panel Component
*
- * Displays meeting methodology progress:
- * - MEDDIC/Challenger checklist
+ * Displays meeting template progress:
+ * - Agenda item checklist
* - Coverage status per item
* - Suggested questions
* - Evidence links
diff --git a/src/renderer/components/copilot/SentimentIndicator.tsx b/src/renderer/components/copilot/SentimentIndicator.tsx
index eaf4963..6a96269 100644
--- a/src/renderer/components/copilot/SentimentIndicator.tsx
+++ b/src/renderer/components/copilot/SentimentIndicator.tsx
@@ -1,7 +1,7 @@
/**
* Sentiment Indicator Component
*
- * Displays customer sentiment with trend visualization.
+ * Displays participant sentiment with trend visualization.
* Compact view for sidebar, expanded view with history.
*/
@@ -125,7 +125,7 @@ export function SentimentIndicator({ className, compact = false }: SentimentIndi
<CardHeader className="pb-2">
<CardTitle className="text-sm font-medium flex items-center gap-2">
<Heart className="h-4 w-4" />
- Customer Sentiment
+ Participant Sentiment
</CardTitle>
</CardHeader>
<CardContent>
@@ -175,7 +175,7 @@ export function SentimentIndicator({ className, compact = false }: SentimentIndi
<div className="flex items-center justify-between">
<CardTitle className="text-sm font-medium flex items-center gap-2">
<Heart className="h-4 w-4" />
- Customer Sentiment
+ Participant Sentiment
</CardTitle>
<Badge
variant={
@@ -225,8 +225,8 @@ export function SentimentIndicator({ className, compact = false }: SentimentIndi
<div className="p-2 bg-amber-50 dark:bg-amber-950/20 rounded border border-amber-200 dark:border-amber-800">
<p className="text-xs text-amber-700 dark:text-amber-400">
{sentiment.current === 'negative'
- ? 'Customer may have concerns - consider addressing them'
- : 'Sentiment is declining - check in with the customer'}
+ ? 'Participant may have concerns - consider addressing them'
+ : 'Sentiment is declining - consider checking in'}
</p>
</div>
)}
diff --git a/src/renderer/components/history/RecordingDetailsModal.tsx b/src/renderer/components/history/RecordingDetailsModal.tsx
index 12afe9a..97359bb 100644
--- a/src/renderer/components/history/RecordingDetailsModal.tsx
+++ b/src/renderer/components/history/RecordingDetailsModal.tsx
@@ -346,10 +346,10 @@ export function RecordingDetailsModal({
</div>
)}
- {/* Customer Pain */}
+ {/* Challenges Discussed */}
{callSummary.customerPain && callSummary.customerPain.length > 0 && (
<div>
- <p className="text-xs font-medium text-muted-foreground mb-1">Customer Pain Points</p>
+ <p className="text-xs font-medium text-muted-foreground mb-1">Challenges Discussed</p>
<ul className="space-y-0.5">
{callSummary.customerPain.map((pain, i) => (
<li key={i} className="text-sm">• {pain}</li>
@@ -366,7 +366,7 @@ export function RecordingDetailsModal({
{callSummary.nextSteps.map((step, i) => (
<div key={i} className="flex items-center gap-2 text-sm">
<Badge variant="outline" className="text-xs">
- {step.owner === 'me' ? 'You' : step.owner === 'them' ? 'Customer' : 'Both'}
+ {step.owner === 'me' ? 'You' : step.owner === 'them' ? 'Them' : 'Both'}
</Badge>
<span>{step.action}</span>
</div>
@@ -375,10 +375,10 @@ export function RecordingDetailsModal({
</div>
)}
- {/* Objections */}
+ {/* Concerns */}
{callSummary.objections && callSummary.objections.length > 0 && (
<div>
- <p className="text-xs font-medium text-muted-foreground mb-1">Objections Raised</p>
+ <p className="text-xs font-medium text-muted-foreground mb-1">Concerns Raised</p>
<div className="space-y-1">
{callSummary.objections.map((obj, i) => (
<div key={i} className="p-2 bg-muted/30 rounded text-sm">
diff --git a/src/renderer/components/settings/CueCardEditor.tsx b/src/renderer/components/settings/CueCardEditor.tsx
index b72c942..ce0e3c2 100644
--- a/src/renderer/components/settings/CueCardEditor.tsx
+++ b/src/renderer/components/settings/CueCardEditor.tsx
@@ -44,22 +44,35 @@ import { Plus, Pencil, Trash2, MessageSquare, HelpCircle, X } from 'lucide-react
import { trpc } from '../../api/trpc';
import { cn } from '../../lib/utils';
-const OBJECTION_TYPES = [
- { value: 'pricing', label: 'Pricing', color: 'bg-green-100 text-green-800' },
- { value: 'timing', label: 'Timing', color: 'bg-amber-100 text-amber-800' },
- { value: 'competitor', label: 'Competitor', color: 'bg-purple-100 text-purple-800' },
- { value: 'authority', label: 'Authority', color: 'bg-blue-100 text-blue-800' },
- { value: 'security', label: 'Security', color: 'bg-red-100 text-red-800' },
- { value: 'integration', label: 'Integration', color: 'bg-cyan-100 text-cyan-800' },
- { value: 'not_interested', label: 'Not Interested', color: 'bg-gray-100 text-gray-800' },
- { value: 'send_info', label: 'Send Info', color: 'bg-indigo-100 text-indigo-800' },
-] as const;
+// New trigger categories (preferred)
+const TRIGGER_CATEGORIES = [
+ { value: 'open_question', label: 'Open Question', color: 'bg-blue-100 text-blue-800' },
+ { value: 'decision_point', label: 'Decision Point', color: 'bg-purple-100 text-purple-800' },
+ { value: 'concern', label: 'Concern', color: 'bg-amber-100 text-amber-800' },
+ { value: 'risk', label: 'Risk', color: 'bg-red-100 text-red-800' },
+ { value: 'commitment', label: 'Commitment', color: 'bg-green-100 text-green-800' },
+ { value: 'follow_up', label: 'Follow Up', color: 'bg-cyan-100 text-cyan-800' },
+ { value: 'information_request', label: 'Info Request', color: 'bg-indigo-100 text-indigo-800' },
+ // Legacy types for backwards compatibility with existing data
+ { value: 'pricing', label: 'Pricing (Legacy)', color: 'bg-green-100 text-green-800' },
+ { value: 'timing', label: 'Timing (Legacy)', color: 'bg-amber-100 text-amber-800' },
+ { value: 'competitor', label: 'Competitor (Legacy)', color: 'bg-purple-100 text-purple-800' },
+ { value: 'authority', label: 'Authority (Legacy)', color: 'bg-blue-100 text-blue-800' },
+ { value: 'security', label: 'Security (Legacy)', color: 'bg-red-100 text-red-800' },
+ { value: 'integration', label: 'Integration (Legacy)', color: 'bg-cyan-100 text-cyan-800' },
+ { value: 'not_interested', label: 'Not Interested (Legacy)', color: 'bg-gray-100 text-gray-800' },
+ { value: 'send_info', label: 'Send Info (Legacy)', color: 'bg-indigo-100 text-indigo-800' },
+];
-type ObjectionType = typeof OBJECTION_TYPES[number]['value'];
+// For backwards compatibility
+const OBJECTION_TYPES = TRIGGER_CATEGORIES;
+
+type TriggerCategory = typeof TRIGGER_CATEGORIES[number]['value'];
+type ObjectionType = string; // Use string for flexibility with both old and new types
interface CueCard {
id: string;
- objectionType: ObjectionType;
+ objectionType: string;
title: string;
talkTracks: string[];
followUpQuestions: string[];
@@ -70,7 +83,7 @@ interface CueCard {
}
interface CueCardFormData {
- objectionType: ObjectionType;
+ objectionType: string;
title: string;
talkTracks: string;
followUpQuestions: string;
@@ -80,7 +93,7 @@ interface CueCardFormData {
}
const emptyForm: CueCardFormData = {
- objectionType: 'pricing',
+ objectionType: 'open_question',
title: '',
talkTracks: '',
followUpQuestions: '',
@@ -123,16 +136,16 @@ function CueCardForm({
<form onSubmit={handleSubmit} className="space-y-4">
<div className="grid grid-cols-2 gap-4">
<div className="space-y-2">
- <Label htmlFor="objectionType">Objection Type</Label>
+ <Label htmlFor="triggerCategory">Trigger Category</Label>
<Select
value={form.objectionType}
- onValueChange={(v) => setForm({ ...form, objectionType: v as ObjectionType })}
+ onValueChange={(v) => setForm({ ...form, objectionType: v })}
>
<SelectTrigger>
<SelectValue />
</SelectTrigger>
<SelectContent>
- {OBJECTION_TYPES.map((type) => (
+ {TRIGGER_CATEGORIES.map((type) => (
<SelectItem key={type.value} value={type.value}>
{type.label}
</SelectItem>
@@ -146,7 +159,7 @@ function CueCardForm({
id="title"
value={form.title}
onChange={(e) => setForm({ ...form, title: e.target.value })}
- placeholder="e.g., Handling Pricing Objections"
+ placeholder="e.g., Responding to Open Questions"
required
/>
</div>
@@ -189,7 +202,7 @@ function CueCardForm({
id="proofPoints"
value={form.proofPoints}
onChange={(e) => setForm({ ...form, proofPoints: e.target.value })}
- placeholder="Average customer sees 3x ROI&#10;Reduces manual work by 40%"
+ placeholder="Key data point or statistic&#10;Reference from documentation"
rows={2}
/>
</div>
@@ -256,7 +269,7 @@ export function CueCardEditor() {
const handleCreate = (data: CueCardFormData) => {
createMutation.mutate({
- objectionType: data.objectionType,
+ objectionType: data.objectionType as TriggerCategory,
title: data.title,
talkTracks: data.talkTracks.split('\n').filter(Boolean),
followUpQuestions: data.followUpQuestions.split('\n').filter(Boolean),
@@ -271,7 +284,7 @@ export function CueCardEditor() {
updateMutation.mutate({
id: editingCard.id,
data: {
- objectionType: data.objectionType,
+ objectionType: data.objectionType as TriggerCategory,
title: data.title,
talkTracks: data.talkTracks.split('\n').filter(Boolean),
followUpQuestions: data.followUpQuestions.split('\n').filter(Boolean),
@@ -290,23 +303,23 @@ export function CueCardEditor() {
<div className="space-y-4">
<div className="flex items-center justify-between">
<div>
- <h3 className="text-lg font-medium">Cue Cards</h3>
+ <h3 className="text-lg font-medium">Smart Cards</h3>
<p className="text-sm text-muted-foreground">
- Customize objection handling cards shown during calls
+ Customize context-aware prompts shown during meetings
</p>
</div>
<Dialog open={isCreateOpen} onOpenChange={setIsCreateOpen}>
<DialogTrigger asChild>
<Button>
<Plus className="h-4 w-4 mr-2" />
- Add Cue Card
+ Add Smart Card
</Button>
</DialogTrigger>
<DialogContent className="max-w-2xl max-h-[90vh] overflow-y-auto">
<DialogHeader>
- <DialogTitle>Create Cue Card</DialogTitle>
+ <DialogTitle>Create Smart Card</DialogTitle>
<DialogDescription>
- Add a new objection handling card with talk tracks and questions.
+ Add a new smart card with suggested responses and follow-up questions.
</DialogDescription>
</DialogHeader>
<CueCardForm
@@ -357,7 +370,7 @@ export function CueCardEditor() {
</AlertDialogTrigger>
<AlertDialogContent>
<AlertDialogHeader>
- <AlertDialogTitle>Delete Cue Card</AlertDialogTitle>
+ <AlertDialogTitle>Delete Smart Card</AlertDialogTitle>
<AlertDialogDescription>
Are you sure you want to delete "{card.title}"? This action cannot be
undone.
@@ -407,7 +420,7 @@ export function CueCardEditor() {
{(!cueCards || cueCards.length === 0) && (
<div className="text-center py-8 text-muted-foreground">
- No cue cards yet. Create one to get started.
+ No smart cards yet. Create one to get started.
</div>
)}
</div>
@@ -417,8 +430,8 @@ export function CueCardEditor() {
<Dialog open={isEditOpen} onOpenChange={setIsEditOpen}>
<DialogContent className="max-w-2xl max-h-[90vh] overflow-y-auto">
<DialogHeader>
- <DialogTitle>Edit Cue Card</DialogTitle>
- <DialogDescription>Update the objection handling card.</DialogDescription>
+ <DialogTitle>Edit Smart Card</DialogTitle>
+ <DialogDescription>Update the smart card content.</DialogDescription>
</DialogHeader>
{editingCard && (
<CueCardForm
diff --git a/src/renderer/components/settings/PlaybookEditor.tsx b/src/renderer/components/settings/PlaybookEditor.tsx
index fc166dc..851a648 100644
--- a/src/renderer/components/settings/PlaybookEditor.tsx
+++ b/src/renderer/components/settings/PlaybookEditor.tsx
@@ -1,8 +1,8 @@
/**
- * Playbook Editor Component
+ * Meeting Template Editor Component
*
- * Allows users to view, create, edit, and manage playbooks
- * (meeting methodologies like MEDDIC, Challenger, etc.)
+ * Allows users to view, create, edit, and manage meeting templates
+ * (1:1s, Project Reviews, Retrospectives, Discovery calls, etc.)
*/
import React, { useState } from 'react';
@@ -51,9 +51,12 @@ import { trpc } from '../../api/trpc';
import { cn } from '../../lib/utils';
const PLAYBOOK_TYPES = [
- { value: 'MEDDIC', label: 'MEDDIC' },
- { value: 'Challenger', label: 'Challenger' },
- { value: 'SPIN', label: 'SPIN' },
+ { value: '1on1', label: '1:1 Check-in' },
+ { value: 'ProjectReview', label: 'Project Review' },
+ { value: 'Retrospective', label: 'Retrospective' },
+ { value: 'Discovery', label: 'Discovery / Requirements' },
+ { value: 'Interview', label: 'Interview' },
+ { value: 'Brainstorm', label: 'Brainstorm / Ideation' },
{ value: 'Custom', label: 'Custom' },
] as const;
@@ -238,7 +241,7 @@ function PlaybookForm({
id="name"
value={form.name}
onChange={(e) => setForm({ ...form, name: e.target.value })}
- placeholder="e.g., Enterprise MEDDIC"
+ placeholder="e.g., Team Weekly 1:1"
required
/>
</div>
@@ -372,9 +375,9 @@ export function PlaybookEditor() {
<div className="space-y-4">
<div className="flex items-center justify-between">
<div>
- <h3 className="text-lg font-medium">Playbooks</h3>
+ <h3 className="text-lg font-medium">Meeting Templates</h3>
<p className="text-sm text-muted-foreground">
- Manage meeting methodology checklists (MEDDIC, Challenger, etc.)
+ Manage meeting agendas and checklists for different meeting types
</p>
</div>
<Dialog open={isCreateOpen} onOpenChange={setIsCreateOpen}>
@@ -386,9 +389,9 @@ export function PlaybookEditor() {
</DialogTrigger>
<DialogContent className="max-w-2xl max-h-[90vh] overflow-y-auto">
<DialogHeader>
- <DialogTitle>Create Playbook</DialogTitle>
+ <DialogTitle>Create Meeting Template</DialogTitle>
<DialogDescription>
- Create a new meeting methodology checklist.
+ Create a new meeting agenda template with discussion topics.
</DialogDescription>
</DialogHeader>
<PlaybookForm
@@ -520,7 +523,7 @@ export function PlaybookEditor() {
<DialogContent className="max-w-2xl max-h-[90vh] overflow-y-auto">
<DialogHeader>
<DialogTitle>Edit Playbook</DialogTitle>
- <DialogDescription>Update the meeting methodology playbook.</DialogDescription>
+ <DialogDescription>Update this meeting template.</DialogDescription>
</DialogHeader>
{editingPlaybook && (
<PlaybookForm
diff --git a/src/renderer/components/transcription/TranscriptionPanel.tsx b/src/renderer/components/transcription/TranscriptionPanel.tsx
index 0fa9517..4b4bcf1 100644
--- a/src/renderer/components/transcription/TranscriptionPanel.tsx
+++ b/src/renderer/components/transcription/TranscriptionPanel.tsx
@@ -2,10 +2,10 @@
* Transcription Panel Component
*
* Modern chat-like interface for live transcription:
- * - Avatar indicators (Me/Customer)
+ * - Avatar indicators (Me/Them)
* - Timestamp badges
* - Styled message bubbles
- * - Objection detection highlighting
+ * - Trigger detection highlighting
* - Auto-scroll to latest
* - Bookmarking support
*/
@@ -72,7 +72,7 @@ function TranscriptMessage({ item, isLive, onBookmark }: TranscriptMessageProps)
isMe ? 'text-blue-600 dark:text-blue-400' : 'text-purple-600 dark:text-purple-400'
)}
>
- {isMe ? 'You' : 'Customer'}
+ {isMe ? 'You' : 'Them'}
</span>
<span className="text-xs text-slate-400">{formatTime(item.timestamp)}</span>
{isLive && (
diff --git a/src/shared/types/ipc.types.ts b/src/shared/types/ipc.types.ts
index 952c637..afb6c7b 100644
--- a/src/shared/types/ipc.types.ts
+++ b/src/shared/types/ipc.types.ts
@@ -135,9 +135,9 @@ export interface CopilotPlaybookSnapshot {
export interface CopilotCallSummary {
bullets: string[];
- customerPain: string[];
- customerGoals: string[];
- objections: Array<{ type: string; text: string; response?: string; resolved: boolean; timestamp: number }>;
+ customerPain: string[]; // Challenges discussed (field name kept for backwards compat)
+ customerGoals: string[]; // Objectives identified (field name kept for backwards compat)
+ objections: Array<{ type: string; text: string; response?: string; resolved: boolean; timestamp: number }>; // Concerns raised
commitments: Array<{ who: 'me' | 'them'; commitment: string; timestamp: number }>;
nextSteps: Array<{ action: string; owner: 'me' | 'them' | 'both'; priority: string; deadline?: string }>;
keyDecisions: string[];