@pellux/goodvibes-agent 0.1.114 → 0.1.116

package/docs/getting-started.md

@@ -46,8 +46,12 @@ bun run dev
 
 After setup has been shown once, the TUI opens directly into the Agent operator workspace. You can also reopen it with `/agent`, `/home`, or `/operator`. That fullscreen workspace is the current front door for setup/config, provider/model selection, Agent Knowledge, local memory/skills/routines/personas, channel readiness, voice/media setup, read-only work/approval/automation views, and explicit GoodVibes TUI build delegation.
 
+The setup workspace scans local Agent behavior folders and shows importable persona, skill, and routine files before asking you to create blank records. Use `/personas discover`, `/agent-skills discover`, and `/routines discover` to preview files, then use the matching import action in the workspace after review.
+
 Use `/agent-profile guide` inside that workspace to walk through starter-profile authoring. It lists built-in and local starters, exports a JSON starter for editing, imports the edited starter back into this Agent home, and creates isolated profiles from the result.
 
+Use `goodvibes-agent profiles create-from-discovered research-desk --yes` or the Profiles workspace form to assemble a local starter template and isolated Agent profile from reviewed discovered persona, skill, and routine files. Use `profiles templates from-discovered <id> --yes` only when you want to save the starter before creating a profile.
+
 Use the Knowledge area in that workspace to ingest a source URL without leaving the TUI. The form requires typed confirmation and writes only to the isolated Agent Knowledge segment.
 
 Use `/schedule receipts` to review redacted local routine promotion history and `/schedule reconcile` to compare those receipts with live connected schedules through public `schedules.list`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.114",
+  "version": "0.1.116",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/behavior-discovery-summary.ts

@@ -0,0 +1,167 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+type DiscoveryOrigin = 'project-local' | 'global';
+
+interface DiscoveryRoot {
+  readonly root: string;
+  readonly origin: DiscoveryOrigin;
+}
+
+interface DiscoveryKindDefinition {
+  readonly roots: readonly DiscoveryRoot[];
+  readonly markers: readonly string[];
+  readonly frontmatterBodyKey?: string;
+}
+
+export interface AgentBehaviorDiscoverySummary {
+  readonly count: number;
+  readonly projectLocalCount: number;
+  readonly globalCount: number;
+  readonly names: readonly string[];
+}
+
+export interface AgentBehaviorDiscoverySnapshot {
+  readonly personas: AgentBehaviorDiscoverySummary;
+  readonly skills: AgentBehaviorDiscoverySummary;
+  readonly routines: AgentBehaviorDiscoverySummary;
+}
+
+const EMPTY_SUMMARY: AgentBehaviorDiscoverySummary = {
+  count: 0,
+  projectLocalCount: 0,
+  globalCount: 0,
+  names: [],
+};
+
+export const EMPTY_AGENT_BEHAVIOR_DISCOVERY_SNAPSHOT: AgentBehaviorDiscoverySnapshot = {
+  personas: EMPTY_SUMMARY,
+  skills: EMPTY_SUMMARY,
+  routines: EMPTY_SUMMARY,
+};
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function markdownBody(content: string): string {
+  return content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+}
+
+function readDiscoveryCandidate(path: string, origin: DiscoveryOrigin, definition: DiscoveryKindDefinition): { readonly name: string; readonly origin: DiscoveryOrigin } | null {
+  let content = '';
+  try {
+    content = readFileSync(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const body = definition.frontmatterBodyKey
+    ? (frontmatter[definition.frontmatterBodyKey] ?? markdownBody(content)).trim()
+    : markdownBody(content);
+  if (body.length === 0) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  const normalized = name.trim();
+  return normalized ? { name: normalized, origin } : null;
+}
+
+function candidatePaths(root: string, entry: string, markers: readonly string[]): readonly string[] {
+  if (entry.endsWith('.md')) return [join(root, entry)];
+  return markers.map((marker) => join(root, entry, marker));
+}
+
+function summarizeDefinition(definition: DiscoveryKindDefinition, limit: number): AgentBehaviorDiscoverySummary {
+  const seen = new Set<string>();
+  const names: string[] = [];
+  let projectLocalCount = 0;
+  let globalCount = 0;
+
+  for (const { root, origin } of definition.roots) {
+    let entries: string[] = [];
+    try {
+      entries = readdirSync(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries.sort((left, right) => left.localeCompare(right))) {
+      for (const path of candidatePaths(root, entry, definition.markers)) {
+        const candidate = readDiscoveryCandidate(path, origin, definition);
+        if (!candidate) continue;
+        const key = candidate.name.toLowerCase();
+        if (seen.has(key)) break;
+        seen.add(key);
+        if (candidate.origin === 'project-local') projectLocalCount += 1;
+        else globalCount += 1;
+        if (names.length < limit) names.push(candidate.name);
+        break;
+      }
+    }
+  }
+
+  if (seen.size === 0) return EMPTY_SUMMARY;
+  return {
+    count: seen.size,
+    projectLocalCount,
+    globalCount,
+    names,
+  };
+}
+
+function definitions(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): AgentBehaviorDiscoverySnapshot {
+  const cwd = shellPaths.workingDirectory;
+  const homeDir = shellPaths.homeDirectory;
+  const personas: DiscoveryKindDefinition = {
+    roots: [
+      { root: join(cwd, '.goodvibes', 'personas'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', 'agents'), origin: 'project-local' },
+      { root: join(homeDir, '.goodvibes', 'personas'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', 'agents'), origin: 'global' },
+    ],
+    markers: ['PERSONA.md', 'persona.md', 'AGENT.md', 'agent.md'],
+    frontmatterBodyKey: 'system_prompt',
+  };
+  const skills: DiscoveryKindDefinition = {
+    roots: [
+      { root: join(cwd, '.goodvibes', 'skills'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'skills'), origin: 'project-local' },
+      { root: join(homeDir, '.goodvibes', 'skills'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'skills'), origin: 'global' },
+    ],
+    markers: ['SKILL.md'],
+  };
+  const routines: DiscoveryKindDefinition = {
+    roots: [
+      { root: join(cwd, '.goodvibes', 'routines'), origin: 'project-local' },
+      { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'project-local' },
+      { root: join(homeDir, '.goodvibes', 'routines'), origin: 'global' },
+      { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'global' },
+    ],
+    markers: ['ROUTINE.md', 'routine.md'],
+    frontmatterBodyKey: 'steps',
+  };
+
+  return {
+    personas: summarizeDefinition(personas, 4),
+    skills: summarizeDefinition(skills, 4),
+    routines: summarizeDefinition(routines, 4),
+  };
+}
+
+export function summarizeAgentBehaviorDiscovery(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'> | undefined): AgentBehaviorDiscoverySnapshot {
+  if (!shellPaths) return EMPTY_AGENT_BEHAVIOR_DISCOVERY_SNAPSHOT;
+  return definitions(shellPaths);
+}

package/src/agent/runtime-profile-starters.ts

@@ -0,0 +1,331 @@
+import type { AgentRuntimeProfileTemplateSummary } from './runtime-profile.ts';
+
+export interface AgentRuntimeProfileStarterTemplate extends AgentRuntimeProfileTemplateSummary {
+  readonly persona: {
+    readonly name: string;
+    readonly description: string;
+    readonly body: string;
+    readonly tags: readonly string[];
+    readonly triggers: readonly string[];
+  };
+  readonly skills: readonly {
+    readonly name: string;
+    readonly description: string;
+    readonly procedure: string;
+    readonly triggers: readonly string[];
+    readonly tags: readonly string[];
+  }[];
+  readonly routines: readonly {
+    readonly name: string;
+    readonly description: string;
+    readonly steps: string;
+    readonly triggers: readonly string[];
+    readonly tags: readonly string[];
+  }[];
+}
+
+export interface AgentRuntimeProfileStarterTemplateFile {
+  readonly version: 1;
+  readonly template: AgentRuntimeProfileStarterTemplate;
+}
+
+export const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] = [
+  {
+    id: 'household',
+    source: 'builtin',
+    name: 'Household Operator',
+    description: 'Coordinate household tasks, home service checks, shared routines, and family logistics.',
+    personaName: 'Household Operator',
+    skillNames: ['Household Triage', 'Home Service Check'],
+    routineNames: ['Weekly Household Review'],
+    persona: {
+      name: 'Household Operator',
+      description: 'Practical assistant for home operations, shared chores, services, and family logistics.',
+      body: [
+        'Operate as a calm household coordinator.',
+        'Track preferences, routines, device/service notes, and recurring decisions in Agent-local memory after they are durable and non-secret.',
+        'Use read-only daemon/operator routes for status checks. Require explicit approval for purchases, messages to other people, service changes, deletions, or secret handling.',
+        'Keep replies concrete: next action, owner, date, and open question when one is needed.',
+      ].join('\n'),
+      tags: ['household', 'home', 'coordination'],
+      triggers: ['home', 'household', 'family', 'chores', 'errands'],
+    },
+    skills: [
+      {
+        name: 'Household Triage',
+        description: 'Turn a household request into owner, urgency, next step, and reminder/delegation posture.',
+        procedure: [
+          '1. Identify whether the task is information, coordination, purchase, repair, or reminder.',
+          '2. Check Agent-local memory for known preferences or constraints before asking repeat questions.',
+          '3. Propose the next non-destructive action. Ask before external messages, payments, account changes, or device/service changes.',
+          '4. Record durable non-secret decisions locally with provenance.',
+        ].join('\n'),
+        triggers: ['plan household', 'home task', 'family logistics'],
+        tags: ['household', 'triage'],
+      },
+      {
+        name: 'Home Service Check',
+        description: 'Review configured services and surface actionable household status without taking hidden action.',
+        procedure: [
+          '1. Inspect configured read-only status, approval, schedule, and knowledge routes.',
+          '2. Summarize degraded services, pending approvals, and stale routines.',
+          '3. Suggest explicit commands for approved follow-up instead of mutating services directly.',
+        ].join('\n'),
+        triggers: ['home status', 'service check', 'household check'],
+        tags: ['household', 'ops'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Weekly Household Review',
+        description: 'Review open household commitments, pending approvals, and stale home notes.',
+        steps: [
+          '1. List pending local routines, workplan tasks, and approvals.',
+          '2. Summarize what changed since the last review from local Agent state.',
+          '3. Ask for confirmation before scheduling, sending messages, purchasing, or changing services.',
+          '4. Record reviewed preferences and stale notes locally.',
+        ].join('\n'),
+        triggers: ['weekly review', 'household review'],
+        tags: ['household', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'research',
+    source: 'builtin',
+    name: 'Research Analyst',
+    description: 'Source-grounded research, brief generation, question tracking, and evidence review.',
+    personaName: 'Research Analyst',
+    skillNames: ['Source-grounded Brief', 'Research Gap Tracker'],
+    routineNames: ['Research Packet Review'],
+    persona: {
+      name: 'Research Analyst',
+      description: 'Evidence-first analyst for research questions, summaries, and decision support.',
+      body: [
+        'Prefer primary sources and cite provenance clearly.',
+        'Use Agent Knowledge only through the isolated Agent knowledge routes.',
+        'Separate findings, confidence, gaps, and recommendations.',
+        'Do not store secrets or unsupported claims as durable knowledge.',
+      ].join('\n'),
+      tags: ['research', 'analysis', 'evidence'],
+      triggers: ['research', 'brief', 'compare', 'investigate'],
+    },
+    skills: [
+      {
+        name: 'Source-grounded Brief',
+        description: 'Produce concise findings with source provenance and confidence.',
+        procedure: [
+          '1. Clarify the decision or question if the request is ambiguous.',
+          '2. Search current sources when freshness matters.',
+          '3. Return answer, evidence, confidence, gaps, and suggested follow-up.',
+          '4. Save durable, reviewed, non-secret facts to Agent-local memory only when useful later.',
+        ].join('\n'),
+        triggers: ['brief me', 'research this', 'compare options'],
+        tags: ['research', 'briefing'],
+      },
+      {
+        name: 'Research Gap Tracker',
+        description: 'Maintain open research questions and stale assumptions.',
+        procedure: [
+          '1. Extract unknowns, weak evidence, and stale facts from the current task.',
+          '2. Convert actionable follow-up into workplan or local routine guidance only after explicit user direction.',
+          '3. Mark resolved gaps with source and date.',
+        ].join('\n'),
+        triggers: ['research gaps', 'unknowns', 'follow up'],
+        tags: ['research', 'quality'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Research Packet Review',
+        description: 'Review recent research notes for stale assumptions and missing citations.',
+        steps: [
+          '1. Inspect local memory/skills/personas relevant to the current topic.',
+          '2. Identify claims lacking provenance.',
+          '3. Recommend refresh searches for time-sensitive claims.',
+          '4. Mark stale local notes instead of deleting them without explicit command intent.',
+        ].join('\n'),
+        triggers: ['review research', 'research packet'],
+        tags: ['research', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'travel',
+    source: 'builtin',
+    name: 'Travel Planner',
+    description: 'Trip planning, itinerary decisions, packing, local constraints, and travel follow-through.',
+    personaName: 'Travel Planner',
+    skillNames: ['Trip Decision Matrix', 'Travel Checklist Builder'],
+    routineNames: ['Pre-trip Readiness Review'],
+    persona: {
+      name: 'Travel Planner',
+      description: 'Travel planning assistant focused on constraints, itinerary tradeoffs, and readiness.',
+      body: [
+        'Track destinations, dates, preferences, constraints, and open decisions locally.',
+        'Search current details for prices, schedules, visa/rule changes, weather, and safety.',
+        'Ask before bookings, purchases, external messages, or account changes.',
+        'Keep recommendations practical and time-aware.',
+      ].join('\n'),
+      tags: ['travel', 'planning', 'logistics'],
+      triggers: ['trip', 'travel', 'itinerary', 'flight', 'hotel'],
+    },
+    skills: [
+      {
+        name: 'Trip Decision Matrix',
+        description: 'Compare travel options against user constraints and live facts.',
+        procedure: [
+          '1. List hard constraints: dates, budget, location, accessibility, work needs, and risk tolerance.',
+          '2. Search current schedule/price/rule data when decisions depend on fresh details.',
+          '3. Present ranked options with tradeoffs and next checks.',
+          '4. Ask for confirmation before bookings or payments.',
+        ].join('\n'),
+        triggers: ['choose travel', 'compare hotels', 'compare flights'],
+        tags: ['travel', 'decision'],
+      },
+      {
+        name: 'Travel Checklist Builder',
+        description: 'Create trip-specific prep lists and reminders from known constraints.',
+        procedure: [
+          '1. Infer trip type and constraints from the current conversation and local memory.',
+          '2. Build checklist sections for documents, packing, transport, lodging, work, health, and communications.',
+          '3. Keep tasks local until the user explicitly requests scheduling or external coordination.',
+        ].join('\n'),
+        triggers: ['packing list', 'trip checklist', 'travel prep'],
+        tags: ['travel', 'checklist'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Pre-trip Readiness Review',
+        description: 'Check documents, reservations, transport, packing, weather, and open decisions.',
+        steps: [
+          '1. Review trip dates, locations, reservations, and open decisions from local Agent state.',
+          '2. Refresh current weather, schedule, and rule data when needed.',
+          '3. Summarize blockers and next confirmed action.',
+          '4. Ask before external sends, purchases, or reservation changes.',
+        ].join('\n'),
+        triggers: ['pre trip review', 'before travel'],
+        tags: ['travel', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'operations',
+    source: 'builtin',
+    name: 'Operations Lead',
+    description: 'Operational monitoring, incident triage, approvals, schedules, and service health.',
+    personaName: 'Operations Lead',
+    skillNames: ['Incident Intake', 'Approval Review'],
+    routineNames: ['Daily Operations Sweep'],
+    persona: {
+      name: 'Operations Lead',
+      description: 'Operator persona for systems, incidents, runbooks, approvals, and service posture.',
+      body: [
+        'Favor explicit state, logs, health, approvals, and next action.',
+        'Use read-only daemon/operator routes by default.',
+        'Require explicit confirmation for run, pause, resume, cancel, retry, approve, deny, service changes, or writes.',
+        'Delegate code/build fixes to GoodVibes TUI when explicitly requested.',
+      ].join('\n'),
+      tags: ['operations', 'incident', 'runbook'],
+      triggers: ['incident', 'ops', 'approval', 'automation', 'service'],
+    },
+    skills: [
+      {
+        name: 'Incident Intake',
+        description: 'Convert a symptom into severity, suspected system, evidence, and next safe checks.',
+        procedure: [
+          '1. Identify symptom, affected surface, time window, severity, and user impact.',
+          '2. Pull read-only status, approvals, schedules, runs, and workplan summaries.',
+          '3. Separate evidence from hypothesis.',
+          '4. Ask before mutating services, automation, schedules, or approvals.',
+        ].join('\n'),
+        triggers: ['incident', 'outage', 'broken', 'triage'],
+        tags: ['operations', 'incident'],
+      },
+      {
+        name: 'Approval Review',
+        description: 'Summarize pending approvals with risk, route, and required decision.',
+        procedure: [
+          '1. List pending approvals and classify risk labels.',
+          '2. Explain what each approval would allow.',
+          '3. Only approve, deny, or cancel from exact user command with confirmation.',
+        ].join('\n'),
+        triggers: ['approvals', 'pending approval', 'review approvals'],
+        tags: ['operations', 'approvals'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Daily Operations Sweep',
+        description: 'Inspect service posture, pending approvals, failed runs, and stale tasks.',
+        steps: [
+          '1. Refresh daemon status, compat, approvals, workplan, automation snapshot, runs, schedules, and capacity.',
+          '2. Summarize degraded items and blocked work.',
+          '3. Recommend exact follow-up commands with confirmation gates for side effects.',
+        ].join('\n'),
+        triggers: ['daily ops', 'operations sweep'],
+        tags: ['operations', 'review'],
+      },
+    ],
+  },
+  {
+    id: 'personal-productivity',
+    source: 'builtin',
+    name: 'Personal Productivity',
+    description: 'Task capture, weekly planning, focus blocks, reminders, and decision hygiene.',
+    personaName: 'Personal Productivity Coach',
+    skillNames: ['Inbox Zero Triage', 'Focus Block Planner'],
+    routineNames: ['Weekly Personal Planning'],
+    persona: {
+      name: 'Personal Productivity Coach',
+      description: 'Personal assistant for task capture, planning, prioritization, and follow-through.',
+      body: [
+        'Keep planning lightweight and action-oriented.',
+        'Capture durable preferences, commitments, and constraints locally when they are useful later.',
+        'Prefer one clear next action over broad plans.',
+        'Ask before sending messages, spending money, changing services, or deleting records.',
+      ].join('\n'),
+      tags: ['productivity', 'planning', 'personal'],
+      triggers: ['plan my day', 'prioritize', 'tasks', 'focus'],
+    },
+    skills: [
+      {
+        name: 'Inbox Zero Triage',
+        description: 'Sort loose tasks into do, delegate, defer, drop, or ask-for-info.',
+        procedure: [
+          '1. Capture each item as an outcome and next action.',
+          '2. Classify by urgency, effort, dependency, and consequence.',
+          '3. Recommend a short ordered list for today and parking lot for later.',
+          '4. Store durable commitments locally with source and date.',
+        ].join('\n'),
+        triggers: ['triage tasks', 'organize tasks', 'inbox'],
+        tags: ['productivity', 'triage'],
+      },
+      {
+        name: 'Focus Block Planner',
+        description: 'Design realistic focus blocks around constraints and energy.',
+        procedure: [
+          '1. Identify available time, constraints, and high-value outcome.',
+          '2. Split work into 25-90 minute blocks with breakpoints.',
+          '3. Keep schedule changes local unless the user explicitly asks for calendar or external updates.',
+        ].join('\n'),
+        triggers: ['focus block', 'plan my day', 'deep work'],
+        tags: ['productivity', 'focus'],
+      },
+    ],
+    routines: [
+      {
+        name: 'Weekly Personal Planning',
+        description: 'Review commitments, priorities, routines, and open decisions for the week.',
+        steps: [
+          '1. Review local tasks, routines, memory, and recent decisions.',
+          '2. Identify top outcomes, blockers, and decisions needed from the user.',
+          '3. Suggest a small weekly plan and ask before creating external reminders or sending messages.',
+        ].join('\n'),
+        triggers: ['weekly planning', 'plan my week'],
+        tags: ['productivity', 'review'],
+      },
+    ],
+  },
+];