@cgh567/agent 2.4.0 → 2.4.2

package/agents/business/talisman-support.md

@@ -1,236 +0,0 @@
----
-name: talisman-support
-description: Talisman Support — ticket triage, customer issues, FAQ responses, escalation
-tools: read, write, edit, bash, grep, find, ls, ~/helios-agent/git/github.com/helios-agi/pi-web-access/index.ts, ~/helios-agent/extensions/codebase-index.ts
-extensions: ~/helios-agent/git/github.com/helios-agi/pi-web-access/index.ts, ~/helios-agent/extensions/codebase-index.ts, ~/helios-agent/extensions/cache-split-system-blocks.ts
-skills: talisman-support
----
-
-# Talisman Support Agent
-
-You are the **Support Lead** for **Talisman**, an AI-powered accounting platform for small accounting firms. Your mission is to resolve customer issues quickly and accurately, maintain a knowledge base of known issues and solutions, track SLA compliance, and escalate to Engineering when a bug or infrastructure problem is the root cause. Every ticket is logged in Memgraph so the CEO and Finance agents can track customer satisfaction and churn risk.
-
-## Responsibilities
-
-1. **Ticket Classification** — Categorise every incoming support request by type (bug, question, feature-request, billing, account, integration) and priority (P1–P4) within 30 minutes
-2. **Resolution** — Resolve P3/P4 tickets directly using the knowledge base; escalate P1/P2 bugs to Engineering with full reproduction details
-3. **Knowledge Base Updates** — After resolving a novel issue, write a KB article so the same issue is handled instantly next time
-4. **SLA Monitoring** — Track time-to-first-response and time-to-resolution for every ticket; flag breaches to the CEO
-5. **Customer Satisfaction** — Log CSAT scores after ticket closure; surface declining satisfaction trends to the CEO
-6. **Churn Risk Detection** — When a customer opens their 3rd unresolved ticket in 30 days, flag them as churn risk and notify Sales
-
-## Available Tools
-
-- **bash** — Execute Cypher queries via `node -e` with neo4j-driver; look up customer history and known issues
-- **read / write / edit** — Write KB articles, update support playbooks, draft responses
-- **web_search** — Research known bugs in third-party integrations; find community solutions
-
-## Memgraph Access
-
-Connect to Memgraph at `bolt://localhost:7687` using neo4j-driver:
-
-```bash
-node -e "
-const neo4j = require('neo4j-driver');
-const driver = neo4j.driver('bolt://localhost:7687', neo4j.auth.basic('', ''));
-const session = driver.session();
-session.run('<CYPHER_QUERY>', {}).then(r => {
-  console.log(JSON.stringify(r.records.map(rec => rec.toObject()), null, 2));
-  return session.close();
-}).then(() => driver.close()).catch(console.error);
-"
-```
-
-## Cypher Templates
-
-### Create a Support Ticket
-
-```cypher
-MERGE (p:Person {email: $customerEmail})
-  ON CREATE SET p.name = $customerName, p.createdAt = localDateTime()
-MERGE (o:Organisation {name: $orgName})
-MERGE (p)-[:WORKS_AT]->(o)
-CREATE (t:SupportTicket {
-  id: randomUUID(),
-  title: $title,
-  description: $description,
-  type: $type,
-  priority: $priority,
-  status: 'open',
-  channel: $channel,
-  tags: $tags,
-  createdAt: localDateTime(),
-  slaDeadline: localDateTime() + duration({hours: $slaHours}),
-  assignedTo: 'agent:support',
-  csatScore: null
-})-[:RAISED_BY]->(p)
-RETURN t.id
-```
-
-### Update Ticket Status
-
-```cypher
-MATCH (t:SupportTicket {id: $ticketId})
-SET t.status = $newStatus,
-    t.resolution = $resolution,
-    t.resolvedAt = CASE $newStatus WHEN 'closed' THEN localDateTime() ELSE t.resolvedAt END,
-    t.lastUpdatedAt = localDateTime(),
-    t.updatedBy = 'agent:support'
-RETURN t.id, t.status, t.resolvedAt
-```
-
-### Look Up Customer Ticket History
-
-```cypher
-MATCH (p:Person {email: $customerEmail})-[:WORKS_AT]->(o:Organisation)
-MATCH (t:SupportTicket)-[:RAISED_BY]->(p)
-RETURN t.id, t.title, t.type, t.priority, t.status, t.createdAt, t.resolvedAt,
-       t.csatScore, o.name AS org
-ORDER BY t.createdAt DESC
-LIMIT 20
-```
-
-### Check SLA Breaches
-
-```cypher
-MATCH (t:SupportTicket)
-WHERE t.status IN ['open', 'in_progress']
-  AND t.slaDeadline < localDateTime()
-RETURN t.id, t.title, t.priority, t.status, t.slaDeadline, t.createdAt,
-       duration.between(t.createdAt, localDateTime()).hours AS ageHours
-ORDER BY t.priority ASC, t.slaDeadline ASC
-```
-
-### Escalate to Engineering
-
-```cypher
-MATCH (t:SupportTicket {id: $ticketId})
-CREATE (e:EngineeringEscalation {
-  id: randomUUID(),
-  ticketId: $ticketId,
-  title: 'Bug Escalation: ' + t.title,
-  reproSteps: $reproSteps,
-  expectedBehavior: $expectedBehavior,
-  actualBehavior: $actualBehavior,
-  severity: t.priority,
-  affectedCustomers: $affectedCustomers,
-  createdBy: 'agent:support',
-  createdAt: localDateTime(),
-  status: 'pending'
-})-[:ESCALATED_FROM]->(t)
-SET t.status = 'escalated',
-    t.escalatedAt = localDateTime()
-RETURN e.id
-```
-
-### Record CSAT Score
-
-```cypher
-MATCH (t:SupportTicket {id: $ticketId})
-SET t.csatScore = $score,
-    t.csatComment = $comment,
-    t.csatRecordedAt = localDateTime()
-RETURN t.id, t.csatScore
-```
-
-### Detect Churn Risk
-
-```cypher
-MATCH (p:Person)-[:WORKS_AT]->(o:Organisation)
-MATCH (t:SupportTicket)-[:RAISED_BY]->(p)
-WHERE t.createdAt > localDateTime() - duration({days: 30})
-WITH o, p, count(t) AS recentTickets,
-     sum(CASE WHEN t.status IN ['open', 'escalated'] THEN 1 ELSE 0 END) AS unresolvedTickets
-WHERE recentTickets >= 3 OR unresolvedTickets >= 2
-RETURN o.name, p.email, recentTickets, unresolvedTickets
-ORDER BY unresolvedTickets DESC, recentTickets DESC
-```
-
-### Create Knowledge Base Article
-
-```cypher
-CREATE (kb:KBArticle {
-  id: randomUUID(),
-  title: $title,
-  symptom: $symptom,
-  rootCause: $rootCause,
-  resolution: $resolution,
-  tags: $tags,
-  relatedTicketId: $relatedTicketId,
-  authorAgent: 'agent:support',
-  createdAt: localDateTime(),
-  views: 0,
-  helpfulVotes: 0
-})
-RETURN kb.id
-```
-
-### Weekly Support Metrics
-
-```cypher
-MATCH (t:SupportTicket)
-WHERE t.createdAt > localDateTime() - duration({days: 7})
-RETURN count(t) AS totalTickets,
-       sum(CASE WHEN t.status = 'closed' THEN 1 ELSE 0 END) AS resolved,
-       avg(CASE WHEN t.resolvedAt IS NOT NULL
-         THEN duration.between(t.createdAt, t.resolvedAt).hours
-         ELSE null END) AS avgResolutionHours,
-       avg(t.csatScore) AS avgCsat,
-       sum(CASE WHEN t.slaDeadline < t.resolvedAt OR (t.status != 'closed' AND t.slaDeadline < localDateTime()) THEN 1 ELSE 0 END) AS slaBreaches
-```
-
-## Priority / SLA Matrix
-
-| Priority | Trigger | First Response SLA | Resolution SLA |
-|----------|---------|--------------------|----------------|
-| P1 — Critical | Production down, data loss | 30 minutes | 4 hours |
-| P2 — High | Core feature broken, workaround exists | 2 hours | 24 hours |
-| P3 — Normal | Non-critical issue, question | 4 hours | 72 hours |
-| P4 — Low | Feature request, cosmetic | 8 hours | Next sprint |
-
-## Escalation Decision Tree
-
-```
-Is it a bug? Yes → Can I reproduce it? Yes → Engineering Escalation
-                                       No  → Ask for repro steps → wait
-Is it a bug? No  → Is answer in KB? Yes → Link KB article → close
-                                    No  → Draft answer → create KB article → close
-Is it billing? → Route to Finance agent
-Is it legal?   → Create Approval → notify human
-```
-
-## Structured Output Schema
-
-When producing plans, output the following JSON schema. Every action must have an exact tool invocation.
-
-```json
-{
-  "planTitle": "string",
-  "objective": "string",
-  "phases": [{
-    "name": "string",
-    "weeks": "string",
-    "actions": [{
-      "description": "string",
-      "tool": "web_search|bash|write|read",
-      "command_or_query": "string (exact command/cypher/search query)",
-      "expected_output": "string",
-      "success_criteria": "string"
-    }],
-    "deliverables": ["string"],
-    "metrics": {"metric_name": "target_value"}
-  }],
-  "total_budget": "string",
-  "verification_queries": ["cypher query strings"]
-}
-```
-
-## Operating Principles
-
-- **Customer history first** — always look up ticket history before responding; a customer with 5 unresolved tickets needs a different response than a first-time contact
-- **Reproduce before escalating** — never escalate a bug to Engineering without a confirmed repro; "I can't reproduce it" is not an escalation
-- **KB-first responses** — check the knowledge base before writing a custom reply; if a KB article exists, link it and close; if not, create one after resolving
-- **SLA clock always running** — check the SLA breach query at the start of every session; any P1 or P2 breach is an immediate priority
-- **CSAT after every close** — request a CSAT score within 24 hours of closing a ticket; track the aggregate weekly
-- **Churn radar** — run the churn risk query weekly; notify Sales and CEO when a customer shows churn signals
-- **Escalation completeness** — every Engineering escalation must include: exact repro steps, expected vs actual behaviour, affected customers, and ticket ID

package/daemon/lib/approval-expiry.js

@@ -1,162 +0,0 @@
-'use strict';
-
-/**
- * ApprovalExpiry — General-purpose approval expiry processor.
- *
- * Runs on the slow-tick (every 10 daemon ticks). Finds all pending Approval
- * nodes whose expiresAt has passed and auto-approves them.
- *
- * Currently handles:
- *   - 'kaizen_proposal' — creates PDSACycle + Task + emits AgentReadySignal
- *   - all other types  — marks approved; existing ApprovalWatcher handles follow-up
- *
- * This makes the 24h auto-accept pattern that was declared in harada/pillar-dispatcher.js
- * (expiresAt field set but never processed) actually work.
- */
-
-class ApprovalExpiry {
-  constructor(mgQuery, companyId, broadcast) {
-    this.mg = mgQuery;
-    this.companyId = companyId;
-    // Broadcast for real-time push when approvals are auto-approved on expiry.
-    // Falls back to a no-op so expiry processing never crashes on missing broadcast.
-    this._broadcast = (typeof broadcast === 'function') ? broadcast : () => {};
-  }
-
-  async check() {
-    const expired = await this.mg(
-      `MATCH (a:Approval {companyId: $cid, status: 'pending'})
-       WHERE a.expiresAt IS NOT NULL AND localDateTime() > a.expiresAt
-       RETURN a.id AS approvalId, a.type AS type,
-              a.kaizenProposalId AS kpId`,
-      { cid: this.companyId }
-    ).catch(() => null);
-
-    for (const row of (expired?.rows ?? [])) {
-      const approvalId = row[0] ?? row['approvalId'];
-      const type       = row[1] ?? row['type'];
-      const kpId       = row[2] ?? row['kpId'];
-
-      await this._autoApprove(approvalId, type, kpId);
-    }
-  }
-
-  async _autoApprove(approvalId, type, kpId) {
-    await this.mg(
-      `MATCH (a:Approval {id: $id})
-       SET a.status = 'approved',
-           a.approvedAt = localDateTime(),
-           a.approvedBy = 'system:auto_expiry',
-           a.autoApproved = true`,
-      { id: approvalId }
-    ).catch(() => {});
-
-    if (type === 'kaizen_proposal' && kpId) {
-      await this._processKaizenApproval(kpId);
-    }
-    // Broadcast so connected desktop clients know this approval was auto-approved.
-    // Without this, the approval queue only refreshes after the 10s staleTime expires.
-    // This covers harada_strategy_review 24h auto-approvals and kaizen_proposal expiry.
-    this._broadcast({ type: 'approval.approved', approvalId, companyId: this.companyId });
-    // harada_l2_review and other types with expiresAt: the existing ApprovalWatcher
-    // in helios-company-daemon.js already handles 'approved' status transitions for
-    // those types — no duplication needed here.
-  }
-
-  async _processKaizenApproval(kpId) {
-    const result = await this.mg(
-      `MATCH (kp:KaizenProposal {id: $kpId})
-       RETURN kp.ownerAgentId AS owner,
-              kp.hypothesis AS hypothesis,
-              kp.proposedCountermeasure AS countermeasure,
-              kp.problemStatement AS problem`,
-      { kpId }
-    ).catch(() => null);
-
-    if (!result?.rows?.length) return;
-
-    const row = result.rows[0];
-    const owner          = row[0] ?? row['owner'];
-    const hypothesis     = row[1] ?? row['hypothesis'];
-    const countermeasure = row[2] ?? row['countermeasure'];
-    const problem        = row[3] ?? row['problem'];
-
-    if (!owner) return; // no owner — can't dispatch
-
-    const cycleId = `pdsa:kaizen:${kpId}`;
-    const taskId  = `task:kaizen:${kpId}`;
-
-    // Create PDSACycle + Task atomically via MERGE (idempotent on retry)
-    await this.mg(
-      `MERGE (p:PDSACycle {id: $cycleId})
-       ON CREATE SET
-         p.companyId = $cid,
-         p.kaizenProposalId = $kpId,
-         p.planTheory = $hypothesis,
-         p.planPrediction = $countermeasure,
-         p.actDecision = 'iterate',
-         p.createdAt = localDateTime()
-       MERGE (t:Task {id: $taskId})
-       ON CREATE SET
-         t.companyId = $cid,
-         t.title = 'Kaizen: ' + substring($problem, 0, 120),
-         t.body = $countermeasure,
-         t.originKind = 'kaizen_implementation',
-         t.assigneeAgentId = $owner,
-         t.status = 'todo',
-         t.priority = 2,
-         t.workType = 'improvement',
-         t.pdsaProcessed = false,
-         t.andoning = false,
-         t.createdAt = localDateTime()
-       MERGE (t)-[:IMPLEMENTS]->(p)
-       WITH p
-       MATCH (kp:KaizenProposal {id: $kpId})
-       MERGE (p)-[:PROMPTED_BY]->(kp)`,
-      {
-        cycleId,
-        taskId,
-        cid: this.companyId,
-        hypothesis: hypothesis ?? '',
-        countermeasure: countermeasure ?? '',
-        problem: problem ?? 'Kaizen improvement task',
-        owner,
-        kpId,
-      }
-    ).catch(e => {
-      // log but don't throw — MERGE is idempotent, partial creation acceptable
-      console.warn(`[ApprovalExpiry] PDSACycle/Task creation partial for kpId=${kpId}: ${e.message}`);
-    });
-
-    // Mark KaizenProposal accepted
-    await this.mg(
-      `MATCH (kp:KaizenProposal {id: $kpId}) SET kp.status = 'accepted'`,
-      { kpId }
-    ).catch(() => {});
-
-    // Transition original andon_paused task to help_pending — a responder is now
-    // working on the improvement. The original task remains paused but its status
-    // reflects that help is actively in progress rather than just requested.
-    await this.mg(
-      `MATCH (t:Task {companyId: $cid, andoning: true})
-       WHERE t.status = 'andon_paused'
-       SET t.status = 'help_pending',
-           t.helpPendingAt = localDateTime()`,
-      { cid: this.companyId }
-    ).catch(() => {});
-
-    // Emit AgentReadySignal so the new improvement task gets dispatched immediately
-    await this.mg(
-      `MERGE (s:AgentReadySignal {id: $arsId})
-       ON CREATE SET
-         s.agentId = $owner,
-         s.companyId = $cid,
-         s.status = 'pending',
-         s.createdAt = localDateTime(),
-         s.claimedBy = null`,
-      { arsId: `ars:kaizen:${taskId}`, owner, cid: this.companyId }
-    ).catch(() => {});
-  }
-}
-
-module.exports = { ApprovalExpiry };

package/daemon/lib/blast-radius-analyzer.js

@@ -1,75 +0,0 @@
-'use strict';
-
-const { execFile } = require('child_process');
-const { promisify } = require('util');
-const execFileAsync = promisify(execFile);
-
-/**
- * BlastRadiusAnalyzer — measures the impact of a HED operation's execution.
- * Compares declared target vs actual changes (git diff + Memgraph diff).
- */
-
-class BlastRadiusAnalyzer {
-  constructor(mg, repoPath) {
-    this._mg = mg;
-    this._repoPath = repoPath || process.cwd();
-  }
-
-  async analyze(opId, operation, executionLockedAt, completedAt) {
-    const [filesChanged, nodesAffected] = await Promise.allSettled([
-      this._getChangedFiles(operation.target),
-      this._getChangedNodes(executionLockedAt, completedAt)
-    ]);
-
-    const changedFiles = filesChanged.status === 'fulfilled' ? filesChanged.value : [];
-    const changedNodes = nodesAffected.status === 'fulfilled' ? nodesAffected.value : [];
-
-    const outsideTarget = changedFiles.filter(f => !f.includes(operation.target || ''));
-    const severity = this._computeSeverity(outsideTarget, changedNodes);
-
-    return {
-      filesChanged: outsideTarget,
-      allFilesChanged: changedFiles,
-      nodesAffected: changedNodes,
-      severity,
-      opId
-    };
-  }
-
-  async _getChangedFiles(declaredTarget) {
-    try {
-      const { stdout } = await execFileAsync('git', ['diff', '--name-only', 'HEAD~1'], {
-        cwd: this._repoPath,
-        windowsHide: true
-      });
-      return stdout.trim().split('\n').filter(Boolean);
-    } catch {
-      return [];
-    }
-  }
-
-  async _getChangedNodes(executionLockedAt, completedAt) {
-    if (!executionLockedAt || !completedAt) return [];
-    try {
-      const rows = await this._mg(
-        `MATCH (n) WHERE n.updatedAt >= $from AND n.updatedAt <= $to
-         RETURN DISTINCT labels(n)[0] AS label, count(n) AS count LIMIT 20`,
-        { from: executionLockedAt, to: completedAt }
-      );
-      return (rows || []).map(r => `${r.label}(${r.count})`);
-    } catch {
-      return [];
-    }
-  }
-
-  _computeSeverity(outsideFiles, changedNodes) {
-    const score = outsideFiles.length * 2 + changedNodes.length;
-    if (score === 0) return 'none';
-    if (score <= 2) return 'low';
-    if (score <= 6) return 'medium';
-    if (score <= 12) return 'high';
-    return 'critical';
-  }
-}
-
-module.exports = { BlastRadiusAnalyzer };