[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7D8JJTZHT4Y41PDC2607EW6":3,"skill-same:01M7D8JJTZHT4Y41PDC2607EW6":79},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":57,"commitSha":58,"skillDirectory":59,"forksCount":14,"repositoryHtmlUrl":60,"repositoryHomepageUrl":6,"ownerHtmlUrl":61,"ownerBlogUrl":62,"ownerDescription":63,"updatedAt":64,"install":65,"resources":78},"01M7D8JJTZHT4Y41PDC2607EW6","Exploratory Test Charter Generator",null,"Generate structured exploratory testing charters with focused missions, time-boxed sessions, risk-based areas, and standardized note-taking templates for systematic exploration","GrupoANDevelopment-m\u002Falberto-ai","GrupoANDevelopment-m","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F257455179?v=4","01M7D69X2N2KEVN0SJF6WGM6SH","Antônio  Ndombe","01M7D69X3P5JTT8H8S904N3888",0,"MIT","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fskills\u002Fqa\u002Fexploratory-test-charter-generator\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: Exploratory Test Charter Generator\ndescription: Generate structured exploratory testing charters with focused missions, time-boxed sessions, risk-based areas, and standardized note-taking templates for systematic exploration\nversion: 1.0.0\nauthor: Pramod\nlicense: MIT\ntags: [exploratory-testing, test-charter, session-based, risk-based, heuristics, test-notes, test-exploration, sbtm]\ntestingTypes: [e2e]\nframeworks: []\nlanguages: [typescript, javascript]\ndomains: [web, api]\nagents: [claude-code, cursor, github-copilot, windsurf, codex, aider, continue, cline, zed, bolt, gemini-cli, amp]\n---\n\n# Exploratory Test Charter Generator Skill\n\nYou are an expert QA engineer specializing in exploratory testing methodology and session-based test management. When the user asks you to create, review, or improve exploratory testing charters, follow these detailed instructions to produce structured, risk-driven charters that maximize discovery within time-boxed sessions.\n\n## Core Principles\n\n1. **Charter-driven exploration** -- Every exploratory session must begin with a clear charter following the \"Explore \u002F With \u002F To Discover\" format. Aimless wandering wastes time; structured freedom finds defects.\n2. **Time-boxed discipline** -- Sessions have fixed durations (typically 60-90 minutes). Respect the boundary. Short sessions maintain focus; long sessions dilute attention.\n3. **Risk-based prioritization** -- Target areas with the highest risk first. Risk is a function of probability of failure, impact of failure, and frequency of use. Never treat all features equally.\n4. **Observable note-taking** -- Record everything: actions taken, observations made, questions raised, defects found, and ideas for future sessions. If it is not written down, it did not happen.\n5. **Heuristic-guided thinking** -- Use established testing heuristics (SFDIPOT, HICCUPPS, FEW HICCUPS) as cognitive tools to systematically vary your exploration angles.\n6. **Debrief accountability** -- Every session ends with a structured debrief. Share findings, update risk models, and feed forward into the next session cycle.\n7. **Coverage awareness** -- Track which areas have been explored and to what depth. Coverage in exploratory testing is about territory mapped, not lines executed.\n8. **Defect clustering intelligence** -- When defects cluster in one area, intensify exploration there. Defects are social creatures; they tend to congregate.\n9. **Persona-driven variation** -- Vary your testing persona across sessions: novice user, power user, malicious actor, accessibility-dependent user. Each persona reveals different classes of defects.\n10. **Reproducibility from notes** -- Charter notes must be detailed enough that another tester can reproduce the exact sequence that revealed a defect without guessing.\n\n## Project Structure\n\n```\ntests\u002F\n  exploratory\u002F\n    charters\u002F\n      charter-template.ts\n      charter-generator.ts\n      charter-registry.ts\n    sessions\u002F\n      session-manager.ts\n      session-timer.ts\n      session-logger.ts\n    heuristics\u002F\n      sfdipot.ts\n      hiccupps.ts\n      touring-heuristics.ts\n    notes\u002F\n      note-template.ts\n      note-formatter.ts\n      defect-classifier.ts\n    coverage\u002F\n      coverage-mapper.ts\n      risk-matrix.ts\n      area-tracker.ts\n    debriefs\u002F\n      debrief-template.ts\n      debrief-aggregator.ts\n    reports\u002F\n      session-report.ts\n      exploration-dashboard.ts\n    config\u002F\n      charter-config.ts\n      heuristic-config.ts\n```\n\n## Charter Format -- The Explore\u002FWith\u002FTo Discover Pattern\n\nThe foundation of every exploratory session is a well-formed charter. The industry-standard format is the three-part charter statement.\n\n### Charter Type Definitions\n\n```typescript\n\u002F\u002F charter-template.ts\ninterface ExploratoryCharter {\n  id: string;\n  title: string;\n  explore: string;       \u002F\u002F The target area or feature\n  with: string;          \u002F\u002F The resources, techniques, or data used\n  toDiscover: string;    \u002F\u002F The information or defects sought\n  priority: 'critical' | 'high' | 'medium' | 'low';\n  riskArea: RiskArea;\n  timeBox: TimeBox;\n  persona: TestPersona;\n  heuristics: string[];\n  preconditions: string[];\n  environment: EnvironmentConfig;\n  createdAt: Date;\n  status: 'draft' | 'ready' | 'in-progress' | 'completed' | 'deferred';\n}\n\ninterface RiskArea {\n  name: string;\n  probability: 1 | 2 | 3 | 4 | 5;\n  impact: 1 | 2 | 3 | 4 | 5;\n  frequency: 1 | 2 | 3 | 4 | 5;\n  riskScore: number;  \u002F\u002F calculated: probability * impact * frequency\n  rationale: string;\n}\n\ninterface TimeBox {\n  duration: number;        \u002F\u002F in minutes\n  setupTime: number;       \u002F\u002F minutes for environment prep\n  explorationTime: number; \u002F\u002F minutes for actual testing\n  debriefTime: number;     \u002F\u002F minutes for notes and reporting\n  breakReminders: boolean;\n}\n\ninterface TestPersona {\n  name: string;\n  description: string;\n  technicalLevel: 'novice' | 'intermediate' | 'expert';\n  motivation: string;\n  commonActions: string[];\n}\n\ninterface EnvironmentConfig {\n  browser?: string;\n  device?: string;\n  networkCondition?: 'fast-3g' | 'slow-3g' | 'offline' | 'broadband';\n  dataState?: string;\n  featureFlags?: Record\u003Cstring, boolean>;\n}\n```\n\n### Charter Generator Implementation\n\n```typescript\n\u002F\u002F charter-generator.ts\nimport { v4 as uuid } from 'uuid';\n\ntype CharterInput = {\n  featureArea: string;\n  recentChanges: string[];\n  knownRisks: string[];\n  userStories: string[];\n  previousFindings: string[];\n};\n\nfunction generateCharters(input: CharterInput): ExploratoryCharter[] {\n  const charters: ExploratoryCharter[] = [];\n\n  \u002F\u002F Generate risk-based charters from known risks\n  for (const risk of input.knownRisks) {\n    charters.push({\n      id: uuid(),\n      title: `Risk exploration: ${risk}`,\n      explore: input.featureArea,\n      with: `targeted scenarios focusing on \"${risk}\" using boundary analysis and error guessing`,\n      toDiscover: `whether the system handles ${risk} gracefully without data loss or security exposure`,\n      priority: 'high',\n      riskArea: assessRisk(risk, input.featureArea),\n      timeBox: createTimeBox(60),\n      persona: selectPersonaForRisk(risk),\n      heuristics: selectHeuristicsForRisk(risk),\n      preconditions: derivePreconditions(input.featureArea, risk),\n      environment: deriveEnvironment(risk),\n      createdAt: new Date(),\n      status: 'ready',\n    });\n  }\n\n  \u002F\u002F Generate change-based charters from recent changes\n  for (const change of input.recentChanges) {\n    charters.push({\n      id: uuid(),\n      title: `Change impact: ${change}`,\n      explore: `areas affected by \"${change}\"`,\n      with: `regression-focused exploration comparing before\u002Fafter behavior`,\n      toDiscover: `unintended side effects or broken workflows introduced by the change`,\n      priority: 'high',\n      riskArea: assessChangeRisk(change),\n      timeBox: createTimeBox(45),\n      persona: { name: 'Power User', description: 'Experienced user who relies on existing workflows', technicalLevel: 'expert', motivation: 'Efficiency and reliability', commonActions: ['keyboard shortcuts', 'batch operations', 'edge case inputs'] },\n      heuristics: ['SFDIPOT', 'Consistency'],\n      preconditions: [`Verify \"${change}\" is deployed to test environment`],\n      environment: { browser: 'chrome', networkCondition: 'broadband' },\n      createdAt: new Date(),\n      status: 'ready',\n    });\n  }\n\n  \u002F\u002F Generate user-story-based charters\n  for (const story of input.userStories) {\n    charters.push({\n      id: uuid(),\n      title: `User story exploration: ${story}`,\n      explore: `the workflow described in \"${story}\"`,\n      with: `happy path and alternative path scenarios, varying input data and user behavior`,\n      toDiscover: `gaps in acceptance criteria, usability issues, and unhandled edge cases`,\n      priority: 'medium',\n      riskArea: assessStoryRisk(story),\n      timeBox: createTimeBox(90),\n      persona: { name: 'New User', description: 'First-time user encountering the feature', technicalLevel: 'novice', motivation: 'Complete task with minimal friction', commonActions: ['reading labels', 'trial and error', 'using defaults'] },\n      heuristics: ['HICCUPPS', 'FEW HICCUPS'],\n      preconditions: [`Test data for \"${story}\" is available`],\n      environment: { browser: 'chrome', device: 'desktop', networkCondition: 'broadband' },\n      createdAt: new Date(),\n      status: 'ready',\n    });\n  }\n\n  return prioritizeCharters(charters);\n}\n\nfunction createTimeBox(totalMinutes: number): TimeBox {\n  return {\n    duration: totalMinutes,\n    setupTime: Math.round(totalMinutes * 0.1),\n    explorationTime: Math.round(totalMinutes * 0.75),\n    debriefTime: Math.round(totalMinutes * 0.15),\n    breakReminders: totalMinutes > 60,\n  };\n}\n\nfunction assessRisk(risk: string, area: string): RiskArea {\n  \u002F\u002F Risk scoring should be calibrated to your domain\n  return {\n    name: `${area} - ${risk}`,\n    probability: 3,\n    impact: 4,\n    frequency: 3,\n    riskScore: 36,\n    rationale: `Known risk \"${risk}\" in ${area} requires targeted exploration`,\n  };\n}\n\nfunction prioritizeCharters(charters: ExploratoryCharter[]): ExploratoryCharter[] {\n  return charters.sort((a, b) => {\n    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };\n    const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];\n    if (priorityDiff !== 0) return priorityDiff;\n    return b.riskArea.riskScore - a.riskArea.riskScore;\n  });\n}\n```\n\n## Session-Based Test Management (SBTM)\n\nSession-Based Test Management provides the structure around exploratory sessions, making them auditable and measurable.\n\n### Session Manager\n\n```typescript\n\u002F\u002F session-manager.ts\ninterface ExploratorySession {\n  id: string;\n  charter: ExploratoryCharter;\n  tester: string;\n  startTime: Date;\n  endTime?: Date;\n  actualDuration?: number;\n  notes: SessionNote[];\n  defects: ExploratoryDefect[];\n  questions: string[];\n  ideas: string[];\n  coverageAreas: CoverageArea[];\n  metrics: SessionMetrics;\n  status: 'setup' | 'exploring' | 'paused' | 'debriefing' | 'completed';\n}\n\ninterface SessionNote {\n  timestamp: Date;\n  type: 'observation' | 'action' | 'question' | 'defect' | 'idea' | 'risk';\n  content: string;\n  screenshot?: string;\n  severity?: 'info' | 'warning' | 'critical';\n}\n\ninterface ExploratoryDefect {\n  id: string;\n  title: string;\n  description: string;\n  stepsToReproduce: string[];\n  expectedBehavior: string;\n  actualBehavior: string;\n  severity: 'blocker' | 'critical' | 'major' | 'minor' | 'trivial';\n  category: DefectCategory;\n  screenshots: string[];\n  environment: string;\n  reproducibility: 'always' | 'sometimes' | 'once' | 'untested';\n}\n\ntype DefectCategory =\n  | 'functional'\n  | 'usability'\n  | 'performance'\n  | 'security'\n  | 'accessibility'\n  | 'data-integrity'\n  | 'visual'\n  | 'compatibility'\n  | 'error-handling';\n\ninterface SessionMetrics {\n  totalNotes: number;\n  defectsFound: number;\n  questionsRaised: number;\n  ideasGenerated: number;\n  areasExplored: number;\n  testDesignPercentage: number;  \u002F\u002F % of time spent designing tests\n  testExecutionPercentage: number; \u002F\u002F % of time spent executing\n  bugInvestigationPercentage: number; \u002F\u002F % of time spent investigating bugs\n  sessionSetupPercentage: number; \u002F\u002F % of time on setup\u002Fconfig\n}\n\nclass SessionManager {\n  private sessions: Map\u003Cstring, ExploratorySession> = new Map();\n\n  startSession(charter: ExploratoryCharter, tester: string): ExploratorySession {\n    const session: ExploratorySession = {\n      id: uuid(),\n      charter,\n      tester,\n      startTime: new Date(),\n      notes: [],\n      defects: [],\n      questions: [],\n      ideas: [],\n      coverageAreas: [],\n      metrics: this.initializeMetrics(),\n      status: 'setup',\n    };\n\n    this.sessions.set(session.id, session);\n    this.startTimer(session);\n    return session;\n  }\n\n  addNote(sessionId: string, note: Omit\u003CSessionNote, 'timestamp'>): void {\n    const session = this.getSession(sessionId);\n    session.notes.push({ ...note, timestamp: new Date() });\n\n    if (note.type === 'defect') session.metrics.defectsFound++;\n    if (note.type === 'question') {\n      session.questions.push(note.content);\n      session.metrics.questionsRaised++;\n    }\n    if (note.type === 'idea') {\n      session.ideas.push(note.content);\n      session.metrics.ideasGenerated++;\n    }\n    session.metrics.totalNotes++;\n  }\n\n  logDefect(sessionId: string, defect: Omit\u003CExploratoryDefect, 'id'>): string {\n    const session = this.getSession(sessionId);\n    const defectWithId = { ...defect, id: uuid() };\n    session.defects.push(defectWithId);\n    session.metrics.defectsFound = session.defects.length;\n\n    this.addNote(sessionId, {\n      type: 'defect',\n      content: `DEFECT: [${defect.severity}] ${defect.title}`,\n      severity: defect.severity === 'blocker' || defect.severity === 'critical' ? 'critical' : 'warning',\n    });\n\n    return defectWithId.id;\n  }\n\n  completeSession(sessionId: string): ExploratorySession {\n    const session = this.getSession(sessionId);\n    session.endTime = new Date();\n    session.actualDuration = Math.round(\n      (session.endTime.getTime() - session.startTime.getTime()) \u002F 60000\n    );\n    session.status = 'completed';\n    session.metrics.areasExplored = session.coverageAreas.length;\n    return session;\n  }\n\n  private getSession(id: string): ExploratorySession {\n    const session = this.sessions.get(id);\n    if (!session) throw new Error(`Session ${id} not found`);\n    return session;\n  }\n\n  private initializeMetrics(): SessionMetrics {\n    return {\n      totalNotes: 0, defectsFound: 0, questionsRaised: 0,\n      ideasGenerated: 0, areasExplored: 0,\n      testDesignPercentage: 0, testExecutionPercentage: 0,\n      bugInvestigationPercentage: 0, sessionSetupPercentage: 0,\n    };\n  }\n\n  private startTimer(session: ExploratorySession): void {\n    const totalMs = session.charter.timeBox.duration * 60 * 1000;\n    setTimeout(() => {\n      if (session.status === 'exploring') {\n        session.status = 'debriefing';\n        console.log(`Session ${session.id}: Time is up. Begin debrief.`);\n      }\n    }, totalMs);\n  }\n}\n```\n\n## Heuristic Cheat Sheets\n\nHeuristics are mental models that guide exploratory testers toward productive areas. They are not checklists; they are thinking tools.\n\n### SFDIPOT (San Francisco Depot) -- Product Element Heuristic\n\n```typescript\n\u002F\u002F sfdipot.ts\ninterface SFDIPOTAnalysis {\n  structure: string[];    \u002F\u002F What the product is made of\n  function: string[];     \u002F\u002F What the product does\n  data: string[];         \u002F\u002F What the product processes\n  interfaces: string[];   \u002F\u002F How the product connects to the world\n  platform: string[];     \u002F\u002F What the product depends on\n  operations: string[];   \u002F\u002F How the product is used in practice\n  time: string[];         \u002F\u002F How the product changes over time\n}\n\nfunction generateSFDIPOTCharters(\n  feature: string,\n  analysis: SFDIPOTAnalysis\n): ExploratoryCharter[] {\n  const charters: ExploratoryCharter[] = [];\n\n  \u002F\u002F Structure exploration\n  for (const item of analysis.structure) {\n    charters.push(buildCharter({\n      title: `Structure: ${item}`,\n      explore: `the structural composition of ${feature}, focusing on ${item}`,\n      with: `inspection of component hierarchy, DOM structure, API response shapes`,\n      toDiscover: `structural inconsistencies, orphaned elements, or missing components in ${item}`,\n    }));\n  }\n\n  \u002F\u002F Function exploration\n  for (const item of analysis.function) {\n    charters.push(buildCharter({\n      title: `Function: ${item}`,\n      explore: `the functional behavior of ${feature} for \"${item}\"`,\n      with: `varied inputs, boundary values, and interrupted workflows`,\n      toDiscover: `functional defects, incorrect calculations, or broken business rules`,\n    }));\n  }\n\n  \u002F\u002F Data exploration\n  for (const item of analysis.data) {\n    charters.push(buildCharter({\n      title: `Data: ${item}`,\n      explore: `data handling in ${feature} concerning \"${item}\"`,\n      with: `extreme values, special characters, empty data, large datasets`,\n      toDiscover: `data corruption, truncation, encoding issues, or loss during transformation`,\n    }));\n  }\n\n  \u002F\u002F Interface exploration\n  for (const item of analysis.interfaces) {\n    charters.push(buildCharter({\n      title: `Interface: ${item}`,\n      explore: `the interface point \"${item}\" in ${feature}`,\n      with: `invalid API responses, timeout simulation, format mismatches`,\n      toDiscover: `integration failures, error handling gaps, or data mapping defects`,\n    }));\n  }\n\n  return charters;\n}\n```\n\n### HICCUPPS -- Consistency Heuristic\n\n```typescript\n\u002F\u002F hiccupps.ts\ninterface HICCUPPSEvaluation {\n  history: string;       \u002F\u002F Is it consistent with past versions?\n  image: string;         \u002F\u002F Is it consistent with the brand\u002Forganization image?\n  comparable: string;    \u002F\u002F Is it consistent with comparable products?\n  claims: string;        \u002F\u002F Is it consistent with what was claimed (specs, docs)?\n  user: string;          \u002F\u002F Is it consistent with user expectations?\n  product: string;       \u002F\u002F Is it consistent within itself?\n  purpose: string;       \u002F\u002F Is it consistent with its explicit purpose?\n  standards: string;     \u002F\u002F Is it consistent with applicable standards?\n}\n\nfunction generateHICCUPPSCharters(\n  feature: string,\n  evaluation: HICCUPPSEvaluation\n): ExploratoryCharter[] {\n  return [\n    buildCharter({\n      title: `Consistency with History`,\n      explore: feature,\n      with: `comparison against previous version behavior documented in ${evaluation.history}`,\n      toDiscover: `regressions or unannounced behavior changes that break user muscle memory`,\n    }),\n    buildCharter({\n      title: `Consistency with Claims`,\n      explore: feature,\n      with: `the specification and marketing materials: ${evaluation.claims}`,\n      toDiscover: `gaps between documented behavior and actual behavior`,\n    }),\n    buildCharter({\n      title: `Consistency with User Expectations`,\n      explore: feature,\n      with: `common user mental models: ${evaluation.user}`,\n      toDiscover: `confusing workflows, unexpected behaviors, or misleading UI elements`,\n    }),\n    buildCharter({\n      title: `Internal Product Consistency`,\n      explore: feature,\n      with: `cross-feature comparison within the product: ${evaluation.product}`,\n      toDiscover: `inconsistent patterns, different behaviors for similar actions, or UI inconsistencies`,\n    }),\n  ];\n}\n```\n\n## Note-Taking Templates\n\nStructured notes transform exploratory sessions from anecdotal to evidential.\n\n### Session Note Template\n\n```typescript\n\u002F\u002F note-template.ts\ninterface SessionNoteTemplate {\n  sessionId: string;\n  charter: string;\n  tester: string;\n  date: string;\n  environment: string;\n  timeBox: string;\n\n  sections: {\n    setup: SetupNotes;\n    exploration: ExplorationLog[];\n    defects: DefectLog[];\n    questions: string[];\n    ideas: string[];\n    risks: string[];\n    coverage: CoverageNotes;\n    debrief: DebriefNotes;\n  };\n}\n\ninterface ExplorationLog {\n  time: string;\n  action: string;\n  observation: string;\n  result: 'pass' | 'fail' | 'investigate' | 'note';\n  screenshot?: string;\n}\n\ninterface DebriefNotes {\n  charterCompleted: boolean;\n  completionPercentage: number;\n  areasNotCovered: string[];\n  topFindings: string[];\n  recommendedFollowUp: string[];\n  riskAssessmentUpdate: string;\n  timeBreakdown: {\n    setup: number;\n    testing: number;\n    bugInvestigation: number;\n    noteWriting: number;\n  };\n}\n\nfunction createNoteTemplate(session: ExploratorySession): SessionNoteTemplate {\n  return {\n    sessionId: session.id,\n    charter: `Explore ${session.charter.explore} With ${session.charter.with} To Discover ${session.charter.toDiscover}`,\n    tester: session.tester,\n    date: new Date().toISOString().split('T')[0],\n    environment: JSON.stringify(session.charter.environment),\n    timeBox: `${session.charter.timeBox.duration} minutes`,\n    sections: {\n      setup: { prerequisites: session.charter.preconditions, dataState: '', environmentReady: false },\n      exploration: [],\n      defects: [],\n      questions: [],\n      ideas: [],\n      risks: [],\n      coverage: { areasPlanned: [], areasVisited: [], depth: {} },\n      debrief: {\n        charterCompleted: false,\n        completionPercentage: 0,\n        areasNotCovered: [],\n        topFindings: [],\n        recommendedFollowUp: [],\n        riskAssessmentUpdate: '',\n        timeBreakdown: { setup: 0, testing: 0, bugInvestigation: 0, noteWriting: 0 },\n      },\n    },\n  };\n}\n```\n\n## Coverage Mapping for Explored Areas\n\nCoverage in exploratory testing is fundamentally different from code coverage. It measures the breadth and depth of territory explored by human intelligence.\n\n```typescript\n\u002F\u002F coverage-mapper.ts\ninterface CoverageArea {\n  id: string;\n  name: string;\n  parent?: string;\n  depth: 'shallow' | 'moderate' | 'deep' | 'exhaustive';\n  sessionsExplored: string[];\n  defectsFound: number;\n  lastExplored: Date;\n  riskLevel: 'high' | 'medium' | 'low';\n  notes: string;\n}\n\ninterface CoverageMap {\n  product: string;\n  areas: CoverageArea[];\n  totalAreas: number;\n  exploredAreas: number;\n  coveragePercentage: number;\n  riskCoverage: {\n    highRiskCovered: number;\n    highRiskTotal: number;\n    mediumRiskCovered: number;\n    mediumRiskTotal: number;\n  };\n}\n\nclass CoverageMapper {\n  private areas: Map\u003Cstring, CoverageArea> = new Map();\n\n  registerArea(area: Omit\u003CCoverageArea, 'sessionsExplored' | 'defectsFound' | 'lastExplored'>): void {\n    this.areas.set(area.id, {\n      ...area,\n      sessionsExplored: [],\n      defectsFound: 0,\n      lastExplored: new Date(0),\n    });\n  }\n\n  recordExploration(areaId: string, sessionId: string, depth: CoverageArea['depth'], defectsFound: number): void {\n    const area = this.areas.get(areaId);\n    if (!area) throw new Error(`Area ${areaId} not registered`);\n\n    area.sessionsExplored.push(sessionId);\n    area.depth = this.deeperOf(area.depth, depth);\n    area.defectsFound += defectsFound;\n    area.lastExplored = new Date();\n  }\n\n  generateCoverageReport(product: string): CoverageMap {\n    const allAreas = Array.from(this.areas.values());\n    const explored = allAreas.filter(a => a.sessionsExplored.length > 0);\n    const highRisk = allAreas.filter(a => a.riskLevel === 'high');\n    const highRiskExplored = highRisk.filter(a => a.sessionsExplored.length > 0);\n\n    return {\n      product,\n      areas: allAreas,\n      totalAreas: allAreas.length,\n      exploredAreas: explored.length,\n      coveragePercentage: Math.round((explored.length \u002F allAreas.length) * 100),\n      riskCoverage: {\n        highRiskCovered: highRiskExplored.length,\n        highRiskTotal: highRisk.length,\n        mediumRiskCovered: allAreas.filter(a => a.riskLevel === 'medium' && a.sessionsExplored.length > 0).length,\n        mediumRiskTotal: allAreas.filter(a => a.riskLevel === 'medium').length,\n      },\n    };\n  }\n\n  getUnexploredHighRiskAreas(): CoverageArea[] {\n    return Array.from(this.areas.values())\n      .filter(a => a.riskLevel === 'high' && a.sessionsExplored.length === 0)\n      .sort((a, b) => a.name.localeCompare(b.name));\n  }\n\n  getStaleAreas(daysThreshold: number): CoverageArea[] {\n    const threshold = new Date();\n    threshold.setDate(threshold.getDate() - daysThreshold);\n    return Array.from(this.areas.values())\n      .filter(a => a.lastExplored \u003C threshold && a.sessionsExplored.length > 0);\n  }\n\n  private deeperOf(current: CoverageArea['depth'], incoming: CoverageArea['depth']): CoverageArea['depth'] {\n    const order: CoverageArea['depth'][] = ['shallow', 'moderate', 'deep', 'exhaustive'];\n    return order.indexOf(incoming) > order.indexOf(current) ? incoming : current;\n  }\n}\n```\n\n## Debrief Session Structure\n\nThe debrief is where raw exploration transforms into organizational knowledge. Every session must include a structured debrief.\n\n```typescript\n\u002F\u002F debrief-template.ts\ninterface DebriefSession {\n  sessionId: string;\n  charter: string;\n  participants: string[];\n  duration: number; \u002F\u002F minutes\n\n  agenda: {\n    charterReview: {\n      wasCharterCompleted: boolean;\n      completionRatio: string; \u002F\u002F e.g., \"80%\"\n      deviations: string[];\n      reasonsForDeviation: string[];\n    };\n\n    findings: {\n      defects: ExploratoryDefect[];\n      observations: string[];\n      risks: string[];\n      questions: string[];\n    };\n\n    coverageAssessment: {\n      areasExplored: string[];\n      areasNotReached: string[];\n      depthAchieved: Record\u003Cstring, string>;\n    };\n\n    nextActions: {\n      followUpCharters: string[];\n      defectsToFile: string[];\n      risksToEscalate: string[];\n      questionsToResearch: string[];\n    };\n\n    metricsUpdate: {\n      sessionDuration: number;\n      percentageOnCharter: number;\n      percentageOnBugInvestigation: number;\n      percentageOnSetup: number;\n      defectsPerHour: number;\n    };\n  };\n}\n\nfunction conductDebrief(session: ExploratorySession): DebriefSession {\n  const duration = session.actualDuration || session.charter.timeBox.duration;\n  const hoursSpent = duration \u002F 60;\n\n  return {\n    sessionId: session.id,\n    charter: `${session.charter.explore} \u002F ${session.charter.with} \u002F ${session.charter.toDiscover}`,\n    participants: [session.tester],\n    duration: session.charter.timeBox.debriefTime,\n    agenda: {\n      charterReview: {\n        wasCharterCompleted: session.coverageAreas.length > 0,\n        completionRatio: `${Math.round((session.coverageAreas.filter(a => a.depth !== 'shallow').length \u002F Math.max(session.coverageAreas.length, 1)) * 100)}%`,\n        deviations: session.notes.filter(n => n.type === 'idea').map(n => n.content),\n        reasonsForDeviation: [],\n      },\n      findings: {\n        defects: session.defects,\n        observations: session.notes.filter(n => n.type === 'observation').map(n => n.content),\n        risks: session.notes.filter(n => n.type === 'risk').map(n => n.content),\n        questions: session.questions,\n      },\n      coverageAssessment: {\n        areasExplored: session.coverageAreas.map(a => a.name),\n        areasNotReached: [],\n        depthAchieved: Object.fromEntries(session.coverageAreas.map(a => [a.name, a.depth])),\n      },\n      nextActions: {\n        followUpCharters: session.ideas,\n        defectsToFile: session.defects.filter(d => d.severity === 'critical' || d.severity === 'blocker').map(d => d.title),\n        risksToEscalate: session.notes.filter(n => n.type === 'risk' && n.severity === 'critical').map(n => n.content),\n        questionsToResearch: session.questions,\n      },\n      metricsUpdate: {\n        sessionDuration: duration,\n        percentageOnCharter: session.metrics.testExecutionPercentage,\n        percentageOnBugInvestigation: session.metrics.bugInvestigationPercentage,\n        percentageOnSetup: session.metrics.sessionSetupPercentage,\n        defectsPerHour: hoursSpent > 0 ? Math.round(session.defects.length \u002F hoursSpent * 10) \u002F 10 : 0,\n      },\n    },\n  };\n}\n```\n\n## Metrics for Exploratory Testing\n\nMeasuring exploratory testing effectiveness requires different metrics than scripted testing.\n\n```typescript\n\u002F\u002F exploration-dashboard.ts\ninterface ExploratoryMetrics {\n  period: { start: Date; end: Date };\n\n  sessionMetrics: {\n    totalSessions: number;\n    totalHours: number;\n    averageSessionLength: number;\n    charterCompletionRate: number;\n  };\n\n  defectMetrics: {\n    totalDefects: number;\n    defectsPerSession: number;\n    defectsPerHour: number;\n    severityDistribution: Record\u003Cstring, number>;\n    categoryDistribution: Record\u003Cstring, number>;\n  };\n\n  coverageMetrics: {\n    totalAreas: number;\n    exploredAreas: number;\n    highRiskCoverage: number;\n    averageDepth: string;\n  };\n\n  qualityIndicators: {\n    defectClusteringIndex: number;  \u002F\u002F how concentrated defects are\n    explorationEfficiency: number;  \u002F\u002F defects found per unit of effort\n    riskReductionRate: number;      \u002F\u002F high-risk areas covered over time\n    sessionProductivity: number;    \u002F\u002F useful findings per session\n  };\n}\n\nfunction calculateExploratoryMetrics(sessions: ExploratorySession[]): ExploratoryMetrics {\n  const completedSessions = sessions.filter(s => s.status === 'completed');\n  const totalMinutes = completedSessions.reduce((sum, s) => sum + (s.actualDuration || 0), 0);\n  const totalHours = totalMinutes \u002F 60;\n  const allDefects = completedSessions.flatMap(s => s.defects);\n\n  const severityDist: Record\u003Cstring, number> = {};\n  for (const defect of allDefects) {\n    severityDist[defect.severity] = (severityDist[defect.severity] || 0) + 1;\n  }\n\n  const categoryDist: Record\u003Cstring, number> = {};\n  for (const defect of allDefects) {\n    categoryDist[defect.category] = (categoryDist[defect.category] || 0) + 1;\n  }\n\n  return {\n    period: {\n      start: completedSessions.length > 0 ? completedSessions[0].startTime : new Date(),\n      end: new Date(),\n    },\n    sessionMetrics: {\n      totalSessions: completedSessions.length,\n      totalHours: Math.round(totalHours * 10) \u002F 10,\n      averageSessionLength: completedSessions.length > 0\n        ? Math.round(totalMinutes \u002F completedSessions.length)\n        : 0,\n      charterCompletionRate: completedSessions.length > 0\n        ? Math.round(\n            (completedSessions.filter(s => s.coverageAreas.length > 0).length \u002F\n              completedSessions.length) * 100\n          )\n        : 0,\n    },\n    defectMetrics: {\n      totalDefects: allDefects.length,\n      defectsPerSession: completedSessions.length > 0\n        ? Math.round((allDefects.length \u002F completedSessions.length) * 10) \u002F 10\n        : 0,\n      defectsPerHour: totalHours > 0\n        ? Math.round((allDefects.length \u002F totalHours) * 10) \u002F 10\n        : 0,\n      severityDistribution: severityDist,\n      categoryDistribution: categoryDist,\n    },\n    coverageMetrics: {\n      totalAreas: 0,\n      exploredAreas: 0,\n      highRiskCoverage: 0,\n      averageDepth: 'moderate',\n    },\n    qualityIndicators: {\n      defectClusteringIndex: calculateClusteringIndex(completedSessions),\n      explorationEfficiency: totalHours > 0 ? allDefects.length \u002F totalHours : 0,\n      riskReductionRate: 0,\n      sessionProductivity: completedSessions.length > 0\n        ? completedSessions.reduce((sum, s) => sum + s.metrics.totalNotes, 0) \u002F completedSessions.length\n        : 0,\n    },\n  };\n}\n\nfunction calculateClusteringIndex(sessions: ExploratorySession[]): number {\n  const areaDefectCounts: Record\u003Cstring, number> = {};\n  for (const session of sessions) {\n    for (const area of session.coverageAreas) {\n      areaDefectCounts[area.name] = (areaDefectCounts[area.name] || 0) + area.defectsFound;\n    }\n  }\n  const counts = Object.values(areaDefectCounts);\n  if (counts.length === 0) return 0;\n  const max = Math.max(...counts);\n  const total = counts.reduce((a, b) => a + b, 0);\n  return total > 0 ? Math.round((max \u002F total) * 100) \u002F 100 : 0;\n}\n```\n\n## Configuration\n\n```typescript\n\u002F\u002F charter-config.ts\ninterface CharterConfig {\n  defaults: {\n    timeBoxMinutes: number;\n    setupPercentage: number;\n    explorationPercentage: number;\n    debriefPercentage: number;\n    breakReminderThreshold: number;\n  };\n  personas: TestPersona[];\n  heuristics: {\n    name: string;\n    description: string;\n    elements: string[];\n  }[];\n  riskThresholds: {\n    high: number;\n    medium: number;\n    low: number;\n  };\n  reportFormat: 'markdown' | 'json' | 'html';\n  screenshotDirectory: string;\n  noteAutoSaveInterval: number; \u002F\u002F seconds\n}\n\nconst defaultConfig: CharterConfig = {\n  defaults: {\n    timeBoxMinutes: 60,\n    setupPercentage: 10,\n    explorationPercentage: 75,\n    debriefPercentage: 15,\n    breakReminderThreshold: 60,\n  },\n  personas: [\n    { name: 'Novice User', description: 'First-time user with no domain knowledge', technicalLevel: 'novice', motivation: 'Complete a task with minimal guidance', commonActions: ['reading help text', 'clicking obvious buttons', 'making mistakes'] },\n    { name: 'Power User', description: 'Experienced user who knows shortcuts', technicalLevel: 'expert', motivation: 'Efficiency and speed', commonActions: ['keyboard shortcuts', 'batch operations', 'customization'] },\n    { name: 'Malicious User', description: 'User attempting to break or exploit the system', technicalLevel: 'expert', motivation: 'Finding vulnerabilities and bypasses', commonActions: ['injection attempts', 'parameter tampering', 'privilege escalation'] },\n    { name: 'Accessibility User', description: 'User relying on assistive technology', technicalLevel: 'intermediate', motivation: 'Using the product with screen reader or keyboard only', commonActions: ['tab navigation', 'screen reader interaction', 'high contrast mode'] },\n  ],\n  heuristics: [\n    { name: 'SFDIPOT', description: 'San Francisco Depot - Product element analysis', elements: ['Structure', 'Function', 'Data', 'Interfaces', 'Platform', 'Operations', 'Time'] },\n    { name: 'HICCUPPS', description: 'Consistency oracle heuristics', elements: ['History', 'Image', 'Comparable', 'Claims', 'User expectations', 'Product', 'Purpose', 'Standards'] },\n    { name: 'FEW HICCUPS', description: 'Extended consistency heuristics', elements: ['Familiarity', 'Explainability', 'World', 'History', 'Image', 'Comparable', 'Claims', 'User expectations', 'Product', 'Standards'] },\n    { name: 'Touring Heuristics', description: 'Tour-based exploration', elements: ['Guidebook tour', 'Money tour', 'Landmark tour', 'Intellectual tour', 'FedEx tour', 'Garbage collector tour', 'Bad neighborhood tour', 'Museum tour'] },\n  ],\n  riskThresholds: { high: 45, medium: 20, low: 0 },\n  reportFormat: 'markdown',\n  screenshotDirectory: '.\u002Ftest-artifacts\u002Fscreenshots',\n  noteAutoSaveInterval: 30,\n};\n```\n\n## Best Practices\n\n1. **Write the charter before the session** -- Crafting the charter is a design activity. Rushing it at session start wastes exploration time. Write charters during planning, not during testing.\n\n2. **Keep sessions between 45 and 90 minutes** -- Shorter sessions lack depth. Longer sessions cause fatigue and reduce defect detection rates. The sweet spot is 60 minutes of exploration with 15 minutes of debrief.\n\n3. **Use one persona per session** -- Switching personas mid-session splits focus. Assign a single persona to each charter and explore consistently through that lens.\n\n4. **Photograph or screenshot every anomaly immediately** -- Visual evidence degrades when you try to reproduce it later. Capture first, investigate second.\n\n5. **Separate observation from interpretation** -- Notes should say \"clicking Submit with empty form shows no error message\" not \"the form validation is broken.\" Record what you see, then analyze in the debrief.\n\n6. **Vary your test oracles across sessions** -- Do not rely on a single oracle (specification). Use history, comparable products, user expectations, and standards as alternative oracles in different sessions.\n\n7. **Track your own testing biases** -- If you always test the same browser, the same data, or the same path first, you create blind spots. Use randomization and heuristic rotation to counteract bias.\n\n8. **Debrief with someone else present** -- A solo debrief is a missed opportunity. Another tester asking \"why did you explore that area?\" forces articulation that reveals gaps and assumptions.\n\n9. **Feed session output into future charters** -- Questions, ideas, and untested areas from one session should directly generate charters for the next cycle. Exploration is iterative, not one-shot.\n\n10. **Maintain a living risk model** -- Update risk assessments after every session. Areas where defects cluster should have their risk scores increased. Areas that have been deeply explored without issues can be deprioritized.\n\n11. **Never skip the setup verification** -- Confirm your environment, data, and access are correct before the timer starts. Discovering a broken test environment 30 minutes into a session is a preventable waste.\n\n12. **Use touring heuristics for unfamiliar features** -- When you do not know a feature well, use the Guidebook Tour (follow the user manual) or the Landmark Tour (visit key capabilities) before attempting creative exploration.\n\n13. **Document what you did NOT test** -- The uncovered areas are as important as the covered ones. Explicitly listing what was not tested makes coverage gaps visible to the team.\n\n14. **Calibrate defect severity during debrief, not during exploration** -- During exploration, capture defects quickly with minimal classification. Refine severity and priority during the structured debrief when you have more context.\n\n## Anti-Patterns to Avoid\n\n1. **Aimless wandering** -- Exploring without a charter is not exploratory testing; it is procrastination. Every session must have a mission. Without a charter, you cannot measure whether you accomplished anything.\n\n2. **Over-scripting the session** -- If your charter specifies exact steps and expected results, you have written a test case, not a charter. Charters set direction; the tester's skill determines the path.\n\n3. **Ignoring the time box** -- Running sessions without a timer or consistently extending sessions \"just five more minutes\" destroys the discipline that makes SBTM work. Respect the boundary.\n\n4. **Treating exploratory testing as only manual clicking** -- Exploratory testing is a cognitive activity, not a click activity. It includes reading logs, querying databases, inspecting network traffic, and analyzing state. Limiting it to the UI limits its power.\n\n5. **Skipping debriefs** -- A session without a debrief produces findings that exist only in one tester's memory. Institutional knowledge requires documentation and sharing.\n\n6. **Confusing coverage breadth with testing quality** -- Touching every feature at a shallow level is worse than deeply exploring high-risk areas. Depth on risk-critical areas outweighs breadth on stable features.\n\n7. **Never rotating personas or heuristics** -- Using the same persona and the same heuristic in every session produces the same type of findings. Rotate systematically.\n\n8. **Filing zero defects as a success indicator** -- Zero defects from an exploratory session might mean the software is good, or it might mean the exploration was ineffective. Evaluate based on coverage depth and note quality, not defect counts alone.\n\n## Debugging Tips\n\n1. **Charter too vague to be actionable** -- If a charter says \"Explore the search feature to find bugs,\" it lacks specificity. Add constraints: which search filters, which data volumes, which user type, which error conditions. A charter should be narrow enough that another tester could pick it up and know exactly where to start.\n\n2. **Sessions consistently running over time** -- This usually means charters are scoped too broadly. Split large charters into smaller, focused ones. A charter covering \"the entire checkout flow\" should become three charters: cart management, payment processing, and order confirmation.\n\n3. **Low defect discovery rate** -- Check whether you are varying your approach enough. If every session uses the same data, same browser, same happy path, you will find diminishing returns. Apply different heuristics, use extreme data, and change the environment.\n\n4. **Notes too sparse to reproduce defects** -- Implement a structured note format with mandatory fields: timestamp, action, input data, expected result, actual result. Train testers to write notes as if someone else will read them.\n\n5. **Team not valuing exploratory sessions** -- Report metrics that management cares about: defects found per hour compared to scripted testing, unique defect categories discovered, risk coverage improvement. Show the return on investment with data.\n\n6. **Coverage map shows blind spots in the same areas repeatedly** -- This indicates a systemic bias. Assign those areas to a different tester, use a different heuristic, or create charters with a different persona to force a fresh perspective.\n\n7. **Debrief sessions feel unproductive** -- Structure them with a fixed agenda: charter review (2 minutes), top findings (5 minutes), coverage assessment (3 minutes), next actions (5 minutes). Time-box the debrief itself to prevent rambling.\n\n8. **Difficulty prioritizing charters** -- Use the risk matrix (probability times impact times frequency) to score every charter. Sort by score. When in doubt, prioritize charters targeting recently changed code, features with a history of defects, or areas where customer complaints have been reported.\n\n9. **Exploration becomes repetitive across sprint cycles** -- Introduce new touring heuristics each sprint. If you used SFDIPOT last sprint, use Touring Heuristics this sprint. Rotate the cognitive tools, not just the features.\n\n10. **Stakeholders question what was tested** -- Generate session reports that map exploration to product areas, include screenshots, and show risk coverage percentages. Exploratory testing is not less rigorous than scripted testing; it merely requires different documentation to prove its value.","# Exploratory Test Charter Generator Skill\n\nYou are an expert QA engineer specializing in exploratory testing methodology and session-based test management. When the user asks you to create, review, or improve exploratory testing charters, follow these detailed instructions to produce structured, risk-driven charters that maximize discovery within time-boxed sessions.\n\n## Core Principles\n\n1. **Charter-driven exploration** -- Every exploratory session must begin with a clear charter following the \"Explore \u002F With \u002F To Discover\" format. Aimless wandering wastes time; structured freedom finds defects.\n2. **Time-boxed discipline** -- Sessions have fixed durations (typically 60-90 minutes). Respect the boundary. Short sessions maintain focus; long sessions dilute attention.\n3. **Risk-based prioritization** -- Target areas with the highest risk first. Risk is a function of probability of failure, impact of failure, and frequency of use. Never treat all features equally.\n4. **Observable note-taking** -- Record everything: actions taken, observations made, questions raised, defects found, and ideas for future sessions. If it is not written down, it did not happen.\n5. **Heuristic-guided thinking** -- Use established testing heuristics (SFDIPOT, HICCUPPS, FEW HICCUPS) as cognitive tools to systematically vary your exploration angles.\n6. **Debrief accountability** -- Every session ends with a structured debrief. Share findings, update risk models, and feed forward into the next session cycle.\n7. **Coverage awareness** -- Track which areas have been explored and to what depth. Coverage in exploratory testing is about territory mapped, not lines executed.\n8. **Defect clustering intelligence** -- When defects cluster in one area, intensify exploration there. Defects are social creatures; they tend to congregate.\n9. **Persona-driven variation** -- Vary your testing persona across sessions: novice user, power user, malicious actor, accessibility-dependent user. Each persona reveals different classes of defects.\n10. **Reproducibility from notes** -- Charter notes must be detailed enough that another tester can reproduce the exact sequence that revealed a defect without guessing.\n\n## Project Structure\n\n```\ntests\u002F\n  exploratory\u002F\n    charters\u002F\n      charter-template.ts\n      charter-generator.ts\n      charter-registry.ts\n    sessions\u002F\n      session-manager.ts\n      session-timer.ts\n      session-logger.ts\n    heuristics\u002F\n      sfdipot.ts\n      hiccupps.ts\n      touring-heuristics.ts\n    notes\u002F\n      note-template.ts\n      note-formatter.ts\n      defect-classifier.ts\n    coverage\u002F\n      coverage-mapper.ts\n      risk-matrix.ts\n      area-tracker.ts\n    debriefs\u002F\n      debrief-template.ts\n      debrief-aggregator.ts\n    reports\u002F\n      session-report.ts\n      exploration-dashboard.ts\n    config\u002F\n      charter-config.ts\n      heuristic-config.ts\n```\n\n## Charter Format -- The Explore\u002FWith\u002FTo Discover Pattern\n\nThe foundation of every exploratory session is a well-formed charter. The industry-standard format is the three-part charter statement.\n\n### Charter Type Definitions\n\n```typescript\n\u002F\u002F charter-template.ts\ninterface ExploratoryCharter {\n  id: string;\n  title: string;\n  explore: string;       \u002F\u002F The target area or feature\n  with: string;          \u002F\u002F The resources, techniques, or data used\n  toDiscover: string;    \u002F\u002F The information or defects sought\n  priority: 'critical' | 'high' | 'medium' | 'low';\n  riskArea: RiskArea;\n  timeBox: TimeBox;\n  persona: TestPersona;\n  heuristics: string[];\n  preconditions: string[];\n  environment: EnvironmentConfig;\n  createdAt: Date;\n  status: 'draft' | 'ready' | 'in-progress' | 'completed' | 'deferred';\n}\n\ninterface RiskArea {\n  name: string;\n  probability: 1 | 2 | 3 | 4 | 5;\n  impact: 1 | 2 | 3 | 4 | 5;\n  frequency: 1 | 2 | 3 | 4 | 5;\n  riskScore: number;  \u002F\u002F calculated: probability * impact * frequency\n  rationale: string;\n}\n\ninterface TimeBox {\n  duration: number;        \u002F\u002F in minutes\n  setupTime: number;       \u002F\u002F minutes for environment prep\n  explorationTime: number; \u002F\u002F minutes for actual testing\n  debriefTime: number;     \u002F\u002F minutes for notes and reporting\n  breakReminders: boolean;\n}\n\ninterface TestPersona {\n  name: string;\n  description: string;\n  technicalLevel: 'novice' | 'intermediate' | 'expert';\n  motivation: string;\n  commonActions: string[];\n}\n\ninterface EnvironmentConfig {\n  browser?: string;\n  device?: string;\n  networkCondition?: 'fast-3g' | 'slow-3g' | 'offline' | 'broadband';\n  dataState?: string;\n  featureFlags?: Record\u003Cstring, boolean>;\n}\n```\n\n### Charter Generator Implementation\n\n```typescript\n\u002F\u002F charter-generator.ts\nimport { v4 as uuid } from 'uuid';\n\ntype CharterInput = {\n  featureArea: string;\n  recentChanges: string[];\n  knownRisks: string[];\n  userStories: string[];\n  previousFindings: string[];\n};\n\nfunction generateCharters(input: CharterInput): ExploratoryCharter[] {\n  const charters: ExploratoryCharter[] = [];\n\n  \u002F\u002F Generate risk-based charters from known risks\n  for (const risk of input.knownRisks) {\n    charters.push({\n      id: uuid(),\n      title: `Risk exploration: ${risk}`,\n      explore: input.featureArea,\n      with: `targeted scenarios focusing on \"${risk}\" using boundary analysis and error guessing`,\n      toDiscover: `whether the system handles ${risk} gracefully without data loss or security exposure`,\n      priority: 'high',\n      riskArea: assessRisk(risk, input.featureArea),\n      timeBox: createTimeBox(60),\n      persona: selectPersonaForRisk(risk),\n      heuristics: selectHeuristicsForRisk(risk),\n      preconditions: derivePreconditions(input.featureArea, risk),\n      environment: deriveEnvironment(risk),\n      createdAt: new Date(),\n      status: 'ready',\n    });\n  }\n\n  \u002F\u002F Generate change-based charters from recent changes\n  for (const change of input.recentChanges) {\n    charters.push({\n      id: uuid(),\n      title: `Change impact: ${change}`,\n      explore: `areas affected by \"${change}\"`,\n      with: `regression-focused exploration comparing before\u002Fafter behavior`,\n      toDiscover: `unintended side effects or broken workflows introduced by the change`,\n      priority: 'high',\n      riskArea: assessChangeRisk(change),\n      timeBox: createTimeBox(45),\n      persona: { name: 'Power User', description: 'Experienced user who relies on existing workflows', technicalLevel: 'expert', motivation: 'Efficiency and reliability', commonActions: ['keyboard shortcuts', 'batch operations', 'edge case inputs'] },\n      heuristics: ['SFDIPOT', 'Consistency'],\n      preconditions: [`Verify \"${change}\" is deployed to test environment`],\n      environment: { browser: 'chrome', networkCondition: 'broadband' },\n      createdAt: new Date(),\n      status: 'ready',\n    });\n  }\n\n  \u002F\u002F Generate user-story-based charters\n  for (const story of input.userStories) {\n    charters.push({\n      id: uuid(),\n      title: `User story exploration: ${story}`,\n      explore: `the workflow described in \"${story}\"`,\n      with: `happy path and alternative path scenarios, varying input data and user behavior`,\n      toDiscover: `gaps in acceptance criteria, usability issues, and unhandled edge cases`,\n      priority: 'medium',\n      riskArea: assessStoryRisk(story),\n      timeBox: createTimeBox(90),\n      persona: { name: 'New User', description: 'First-time user encountering the feature', technicalLevel: 'novice', motivation: 'Complete task with minimal friction', commonActions: ['reading labels', 'trial and error', 'using defaults'] },\n      heuristics: ['HICCUPPS', 'FEW HICCUPS'],\n      preconditions: [`Test data for \"${story}\" is available`],\n      environment: { browser: 'chrome', device: 'desktop', networkCondition: 'broadband' },\n      createdAt: new Date(),\n      status: 'ready',\n    });\n  }\n\n  return prioritizeCharters(charters);\n}\n\nfunction createTimeBox(totalMinutes: number): TimeBox {\n  return {\n    duration: totalMinutes,\n    setupTime: Math.round(totalMinutes * 0.1),\n    explorationTime: Math.round(totalMinutes * 0.75),\n    debriefTime: Math.round(totalMinutes * 0.15),\n    breakReminders: totalMinutes > 60,\n  };\n}\n\nfunction assessRisk(risk: string, area: string): RiskArea {\n  \u002F\u002F Risk scoring should be calibrated to your domain\n  return {\n    name: `${area} - ${risk}`,\n    probability: 3,\n    impact: 4,\n    frequency: 3,\n    riskScore: 36,\n    rationale: `Known risk \"${risk}\" in ${area} requires targeted exploration`,\n  };\n}\n\nfunction prioritizeCharters(charters: ExploratoryCharter[]): ExploratoryCharter[] {\n  return charters.sort((a, b) => {\n    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };\n    const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];\n    if (priorityDiff !== 0) return priorityDiff;\n    return b.riskArea.riskScore - a.riskArea.riskScore;\n  });\n}\n```\n\n## Session-Based Test Management (SBTM)\n\nSession-Based Test Management provides the structure around exploratory sessions, making them auditable and measurable.\n\n### Session Manager\n\n```typescript\n\u002F\u002F session-manager.ts\ninterface ExploratorySession {\n  id: string;\n  charter: ExploratoryCharter;\n  tester: string;\n  startTime: Date;\n  endTime?: Date;\n  actualDuration?: number;\n  notes: SessionNote[];\n  defects: ExploratoryDefect[];\n  questions: string[];\n  ideas: string[];\n  coverageAreas: CoverageArea[];\n  metrics: SessionMetrics;\n  status: 'setup' | 'exploring' | 'paused' | 'debriefing' | 'completed';\n}\n\ninterface SessionNote {\n  timestamp: Date;\n  type: 'observation' | 'action' | 'question' | 'defect' | 'idea' | 'risk';\n  content: string;\n  screenshot?: string;\n  severity?: 'info' | 'warning' | 'critical';\n}\n\ninterface ExploratoryDefect {\n  id: string;\n  title: string;\n  description: string;\n  stepsToReproduce: string[];\n  expectedBehavior: string;\n  actualBehavior: string;\n  severity: 'blocker' | 'critical' | 'major' | 'minor' | 'trivial';\n  category: DefectCategory;\n  screenshots: string[];\n  environment: string;\n  reproducibility: 'always' | 'sometimes' | 'once' | 'untested';\n}\n\ntype DefectCategory =\n  | 'functional'\n  | 'usability'\n  | 'performance'\n  | 'security'\n  | 'accessibility'\n  | 'data-integrity'\n  | 'visual'\n  | 'compatibility'\n  | 'error-handling';\n\ninterface SessionMetrics {\n  totalNotes: number;\n  defectsFound: number;\n  questionsRaised: number;\n  ideasGenerated: number;\n  areasExplored: number;\n  testDesignPercentage: number;  \u002F\u002F % of time spent designing tests\n  testExecutionPercentage: number; \u002F\u002F % of time spent executing\n  bugInvestigationPercentage: number; \u002F\u002F % of time spent investigating bugs\n  sessionSetupPercentage: number; \u002F\u002F % of time on setup\u002Fconfig\n}\n\nclass SessionManager {\n  private sessions: Map\u003Cstring, ExploratorySession> = new Map();\n\n  startSession(charter: ExploratoryCharter, tester: string): ExploratorySession {\n    const session: ExploratorySession = {\n      id: uuid(),\n      charter,\n      tester,\n      startTime: new Date(),\n      notes: [],\n      defects: [],\n      questions: [],\n      ideas: [],\n      coverageAreas: [],\n      metrics: this.initializeMetrics(),\n      status: 'setup',\n    };\n\n    this.sessions.set(session.id, session);\n    this.startTimer(session);\n    return session;\n  }\n\n  addNote(sessionId: string, note: Omit\u003CSessionNote, 'timestamp'>): void {\n    const session = this.getSession(sessionId);\n    session.notes.push({ ...note, timestamp: new Date() });\n\n    if (note.type === 'defect') session.metrics.defectsFound++;\n    if (note.type === 'question') {\n      session.questions.push(note.content);\n      session.metrics.questionsRaised++;\n    }\n    if (note.type === 'idea') {\n      session.ideas.push(note.content);\n      session.metrics.ideasGenerated++;\n    }\n    session.metrics.totalNotes++;\n  }\n\n  logDefect(sessionId: string, defect: Omit\u003CExploratoryDefect, 'id'>): string {\n    const session = this.getSession(sessionId);\n    const defectWithId = { ...defect, id: uuid() };\n    session.defects.push(defectWithId);\n    session.metrics.defectsFound = session.defects.length;\n\n    this.addNote(sessionId, {\n      type: 'defect',\n      content: `DEFECT: [${defect.severity}] ${defect.title}`,\n      severity: defect.severity === 'blocker' || defect.severity === 'critical' ? 'critical' : 'warning',\n    });\n\n    return defectWithId.id;\n  }\n\n  completeSession(sessionId: string): ExploratorySession {\n    const session = this.getSession(sessionId);\n    session.endTime = new Date();\n    session.actualDuration = Math.round(\n      (session.endTime.getTime() - session.startTime.getTime()) \u002F 60000\n    );\n    session.status = 'completed';\n    session.metrics.areasExplored = session.coverageAreas.length;\n    return session;\n  }\n\n  private getSession(id: string): ExploratorySession {\n    const session = this.sessions.get(id);\n    if (!session) throw new Error(`Session ${id} not found`);\n    return session;\n  }\n\n  private initializeMetrics(): SessionMetrics {\n    return {\n      totalNotes: 0, defectsFound: 0, questionsRaised: 0,\n      ideasGenerated: 0, areasExplored: 0,\n      testDesignPercentage: 0, testExecutionPercentage: 0,\n      bugInvestigationPercentage: 0, sessionSetupPercentage: 0,\n    };\n  }\n\n  private startTimer(session: ExploratorySession): void {\n    const totalMs = session.charter.timeBox.duration * 60 * 1000;\n    setTimeout(() => {\n      if (session.status === 'exploring') {\n        session.status = 'debriefing';\n        console.log(`Session ${session.id}: Time is up. Begin debrief.`);\n      }\n    }, totalMs);\n  }\n}\n```\n\n## Heuristic Cheat Sheets\n\nHeuristics are mental models that guide exploratory testers toward productive areas. They are not checklists; they are thinking tools.\n\n### SFDIPOT (San Francisco Depot) -- Product Element Heuristic\n\n```typescript\n\u002F\u002F sfdipot.ts\ninterface SFDIPOTAnalysis {\n  structure: string[];    \u002F\u002F What the product is made of\n  function: string[];     \u002F\u002F What the product does\n  data: string[];         \u002F\u002F What the product processes\n  interfaces: string[];   \u002F\u002F How the product connects to the world\n  platform: string[];     \u002F\u002F What the product depends on\n  operations: string[];   \u002F\u002F How the product is used in practice\n  time: string[];         \u002F\u002F How the product changes over time\n}\n\nfunction generateSFDIPOTCharters(\n  feature: string,\n  analysis: SFDIPOTAnalysis\n): ExploratoryCharter[] {\n  const charters: ExploratoryCharter[] = [];\n\n  \u002F\u002F Structure exploration\n  for (const item of analysis.structure) {\n    charters.push(buildCharter({\n      title: `Structure: ${item}`,\n      explore: `the structural composition of ${feature}, focusing on ${item}`,\n      with: `inspection of component hierarchy, DOM structure, API response shapes`,\n      toDiscover: `structural inconsistencies, orphaned elements, or missing components in ${item}`,\n    }));\n  }\n\n  \u002F\u002F Function exploration\n  for (const item of analysis.function) {\n    charters.push(buildCharter({\n      title: `Function: ${item}`,\n      explore: `the functional behavior of ${feature} for \"${item}\"`,\n      with: `varied inputs, boundary values, and interrupted workflows`,\n      toDiscover: `functional defects, incorrect calculations, or broken business rules`,\n    }));\n  }\n\n  \u002F\u002F Data exploration\n  for (const item of analysis.data) {\n    charters.push(buildCharter({\n      title: `Data: ${item}`,\n      explore: `data handling in ${feature} concerning \"${item}\"`,\n      with: `extreme values, special characters, empty data, large datasets`,\n      toDiscover: `data corruption, truncation, encoding issues, or loss during transformation`,\n    }));\n  }\n\n  \u002F\u002F Interface exploration\n  for (const item of analysis.interfaces) {\n    charters.push(buildCharter({\n      title: `Interface: ${item}`,\n      explore: `the interface point \"${item}\" in ${feature}`,\n      with: `invalid API responses, timeout simulation, format mismatches`,\n      toDiscover: `integration failures, error handling gaps, or data mapping defects`,\n    }));\n  }\n\n  return charters;\n}\n```\n\n### HICCUPPS -- Consistency Heuristic\n\n```typescript\n\u002F\u002F hiccupps.ts\ninterface HICCUPPSEvaluation {\n  history: string;       \u002F\u002F Is it consistent with past versions?\n  image: string;         \u002F\u002F Is it consistent with the brand\u002Forganization image?\n  comparable: string;    \u002F\u002F Is it consistent with comparable products?\n  claims: string;        \u002F\u002F Is it consistent with what was claimed (specs, docs)?\n  user: string;          \u002F\u002F Is it consistent with user expectations?\n  product: string;       \u002F\u002F Is it consistent within itself?\n  purpose: string;       \u002F\u002F Is it consistent with its explicit purpose?\n  standards: string;     \u002F\u002F Is it consistent with applicable standards?\n}\n\nfunction generateHICCUPPSCharters(\n  feature: string,\n  evaluation: HICCUPPSEvaluation\n): ExploratoryCharter[] {\n  return [\n    buildCharter({\n      title: `Consistency with History`,\n      explore: feature,\n      with: `comparison against previous version behavior documented in ${evaluation.history}`,\n      toDiscover: `regressions or unannounced behavior changes that break user muscle memory`,\n    }),\n    buildCharter({\n      title: `Consistency with Claims`,\n      explore: feature,\n      with: `the specification and marketing materials: ${evaluation.claims}`,\n      toDiscover: `gaps between documented behavior and actual behavior`,\n    }),\n    buildCharter({\n      title: `Consistency with User Expectations`,\n      explore: feature,\n      with: `common user mental models: ${evaluation.user}`,\n      toDiscover: `confusing workflows, unexpected behaviors, or misleading UI elements`,\n    }),\n    buildCharter({\n      title: `Internal Product Consistency`,\n      explore: feature,\n      with: `cross-feature comparison within the product: ${evaluation.product}`,\n      toDiscover: `inconsistent patterns, different behaviors for similar actions, or UI inconsistencies`,\n    }),\n  ];\n}\n```\n\n## Note-Taking Templates\n\nStructured notes transform exploratory sessions from anecdotal to evidential.\n\n### Session Note Template\n\n```typescript\n\u002F\u002F note-template.ts\ninterface SessionNoteTemplate {\n  sessionId: string;\n  charter: string;\n  tester: string;\n  date: string;\n  environment: string;\n  timeBox: string;\n\n  sections: {\n    setup: SetupNotes;\n    exploration: ExplorationLog[];\n    defects: DefectLog[];\n    questions: string[];\n    ideas: string[];\n    risks: string[];\n    coverage: CoverageNotes;\n    debrief: DebriefNotes;\n  };\n}\n\ninterface ExplorationLog {\n  time: string;\n  action: string;\n  observation: string;\n  result: 'pass' | 'fail' | 'investigate' | 'note';\n  screenshot?: string;\n}\n\ninterface DebriefNotes {\n  charterCompleted: boolean;\n  completionPercentage: number;\n  areasNotCovered: string[];\n  topFindings: string[];\n  recommendedFollowUp: string[];\n  riskAssessmentUpdate: string;\n  timeBreakdown: {\n    setup: number;\n    testing: number;\n    bugInvestigation: number;\n    noteWriting: number;\n  };\n}\n\nfunction createNoteTemplate(session: ExploratorySession): SessionNoteTemplate {\n  return {\n    sessionId: session.id,\n    charter: `Explore ${session.charter.explore} With ${session.charter.with} To Discover ${session.charter.toDiscover}`,\n    tester: session.tester,\n    date: new Date().toISOString().split('T')[0],\n    environment: JSON.stringify(session.charter.environment),\n    timeBox: `${session.charter.timeBox.duration} minutes`,\n    sections: {\n      setup: { prerequisites: session.charter.preconditions, dataState: '', environmentReady: false },\n      exploration: [],\n      defects: [],\n      questions: [],\n      ideas: [],\n      risks: [],\n      coverage: { areasPlanned: [], areasVisited: [], depth: {} },\n      debrief: {\n        charterCompleted: false,\n        completionPercentage: 0,\n        areasNotCovered: [],\n        topFindings: [],\n        recommendedFollowUp: [],\n        riskAssessmentUpdate: '',\n        timeBreakdown: { setup: 0, testing: 0, bugInvestigation: 0, noteWriting: 0 },\n      },\n    },\n  };\n}\n```\n\n## Coverage Mapping for Explored Areas\n\nCoverage in exploratory testing is fundamentally different from code coverage. It measures the breadth and depth of territory explored by human intelligence.\n\n```typescript\n\u002F\u002F coverage-mapper.ts\ninterface CoverageArea {\n  id: string;\n  name: string;\n  parent?: string;\n  depth: 'shallow' | 'moderate' | 'deep' | 'exhaustive';\n  sessionsExplored: string[];\n  defectsFound: number;\n  lastExplored: Date;\n  riskLevel: 'high' | 'medium' | 'low';\n  notes: string;\n}\n\ninterface CoverageMap {\n  product: string;\n  areas: CoverageArea[];\n  totalAreas: number;\n  exploredAreas: number;\n  coveragePercentage: number;\n  riskCoverage: {\n    highRiskCovered: number;\n    highRiskTotal: number;\n    mediumRiskCovered: number;\n    mediumRiskTotal: number;\n  };\n}\n\nclass CoverageMapper {\n  private areas: Map\u003Cstring, CoverageArea> = new Map();\n\n  registerArea(area: Omit\u003CCoverageArea, 'sessionsExplored' | 'defectsFound' | 'lastExplored'>): void {\n    this.areas.set(area.id, {\n      ...area,\n      sessionsExplored: [],\n      defectsFound: 0,\n      lastExplored: new Date(0),\n    });\n  }\n\n  recordExploration(areaId: string, sessionId: string, depth: CoverageArea['depth'], defectsFound: number): void {\n    const area = this.areas.get(areaId);\n    if (!area) throw new Error(`Area ${areaId} not registered`);\n\n    area.sessionsExplored.push(sessionId);\n    area.depth = this.deeperOf(area.depth, depth);\n    area.defectsFound += defectsFound;\n    area.lastExplored = new Date();\n  }\n\n  generateCoverageReport(product: string): CoverageMap {\n    const allAreas = Array.from(this.areas.values());\n    const explored = allAreas.filter(a => a.sessionsExplored.length > 0);\n    const highRisk = allAreas.filter(a => a.riskLevel === 'high');\n    const highRiskExplored = highRisk.filter(a => a.sessionsExplored.length > 0);\n\n    return {\n      product,\n      areas: allAreas,\n      totalAreas: allAreas.length,\n      exploredAreas: explored.length,\n      coveragePercentage: Math.round((explored.length \u002F allAreas.length) * 100),\n      riskCoverage: {\n        highRiskCovered: highRiskExplored.length,\n        highRiskTotal: highRisk.length,\n        mediumRiskCovered: allAreas.filter(a => a.riskLevel === 'medium' && a.sessionsExplored.length > 0).length,\n        mediumRiskTotal: allAreas.filter(a => a.riskLevel === 'medium').length,\n      },\n    };\n  }\n\n  getUnexploredHighRiskAreas(): CoverageArea[] {\n    return Array.from(this.areas.values())\n      .filter(a => a.riskLevel === 'high' && a.sessionsExplored.length === 0)\n      .sort((a, b) => a.name.localeCompare(b.name));\n  }\n\n  getStaleAreas(daysThreshold: number): CoverageArea[] {\n    const threshold = new Date();\n    threshold.setDate(threshold.getDate() - daysThreshold);\n    return Array.from(this.areas.values())\n      .filter(a => a.lastExplored \u003C threshold && a.sessionsExplored.length > 0);\n  }\n\n  private deeperOf(current: CoverageArea['depth'], incoming: CoverageArea['depth']): CoverageArea['depth'] {\n    const order: CoverageArea['depth'][] = ['shallow', 'moderate', 'deep', 'exhaustive'];\n    return order.indexOf(incoming) > order.indexOf(current) ? incoming : current;\n  }\n}\n```\n\n## Debrief Session Structure\n\nThe debrief is where raw exploration transforms into organizational knowledge. Every session must include a structured debrief.\n\n```typescript\n\u002F\u002F debrief-template.ts\ninterface DebriefSession {\n  sessionId: string;\n  charter: string;\n  participants: string[];\n  duration: number; \u002F\u002F minutes\n\n  agenda: {\n    charterReview: {\n      wasCharterCompleted: boolean;\n      completionRatio: string; \u002F\u002F e.g., \"80%\"\n      deviations: string[];\n      reasonsForDeviation: string[];\n    };\n\n    findings: {\n      defects: ExploratoryDefect[];\n      observations: string[];\n      risks: string[];\n      questions: string[];\n    };\n\n    coverageAssessment: {\n      areasExplored: string[];\n      areasNotReached: string[];\n      depthAchieved: Record\u003Cstring, string>;\n    };\n\n    nextActions: {\n      followUpCharters: string[];\n      defectsToFile: string[];\n      risksToEscalate: string[];\n      questionsToResearch: string[];\n    };\n\n    metricsUpdate: {\n      sessionDuration: number;\n      percentageOnCharter: number;\n      percentageOnBugInvestigation: number;\n      percentageOnSetup: number;\n      defectsPerHour: number;\n    };\n  };\n}\n\nfunction conductDebrief(session: ExploratorySession): DebriefSession {\n  const duration = session.actualDuration || session.charter.timeBox.duration;\n  const hoursSpent = duration \u002F 60;\n\n  return {\n    sessionId: session.id,\n    charter: `${session.charter.explore} \u002F ${session.charter.with} \u002F ${session.charter.toDiscover}`,\n    participants: [session.tester],\n    duration: session.charter.timeBox.debriefTime,\n    agenda: {\n      charterReview: {\n        wasCharterCompleted: session.coverageAreas.length > 0,\n        completionRatio: `${Math.round((session.coverageAreas.filter(a => a.depth !== 'shallow').length \u002F Math.max(session.coverageAreas.length, 1)) * 100)}%`,\n        deviations: session.notes.filter(n => n.type === 'idea').map(n => n.content),\n        reasonsForDeviation: [],\n      },\n      findings: {\n        defects: session.defects,\n        observations: session.notes.filter(n => n.type === 'observation').map(n => n.content),\n        risks: session.notes.filter(n => n.type === 'risk').map(n => n.content),\n        questions: session.questions,\n      },\n      coverageAssessment: {\n        areasExplored: session.coverageAreas.map(a => a.name),\n        areasNotReached: [],\n        depthAchieved: Object.fromEntries(session.coverageAreas.map(a => [a.name, a.depth])),\n      },\n      nextActions: {\n        followUpCharters: session.ideas,\n        defectsToFile: session.defects.filter(d => d.severity === 'critical' || d.severity === 'blocker').map(d => d.title),\n        risksToEscalate: session.notes.filter(n => n.type === 'risk' && n.severity === 'critical').map(n => n.content),\n        questionsToResearch: session.questions,\n      },\n      metricsUpdate: {\n        sessionDuration: duration,\n        percentageOnCharter: session.metrics.testExecutionPercentage,\n        percentageOnBugInvestigation: session.metrics.bugInvestigationPercentage,\n        percentageOnSetup: session.metrics.sessionSetupPercentage,\n        defectsPerHour: hoursSpent > 0 ? Math.round(session.defects.length \u002F hoursSpent * 10) \u002F 10 : 0,\n      },\n    },\n  };\n}\n```\n\n## Metrics for Exploratory Testing\n\nMeasuring exploratory testing effectiveness requires different metrics than scripted testing.\n\n```typescript\n\u002F\u002F exploration-dashboard.ts\ninterface ExploratoryMetrics {\n  period: { start: Date; end: Date };\n\n  sessionMetrics: {\n    totalSessions: number;\n    totalHours: number;\n    averageSessionLength: number;\n    charterCompletionRate: number;\n  };\n\n  defectMetrics: {\n    totalDefects: number;\n    defectsPerSession: number;\n    defectsPerHour: number;\n    severityDistribution: Record\u003Cstring, number>;\n    categoryDistribution: Record\u003Cstring, number>;\n  };\n\n  coverageMetrics: {\n    totalAreas: number;\n    exploredAreas: number;\n    highRiskCoverage: number;\n    averageDepth: string;\n  };\n\n  qualityIndicators: {\n    defectClusteringIndex: number;  \u002F\u002F how concentrated defects are\n    explorationEfficiency: number;  \u002F\u002F defects found per unit of effort\n    riskReductionRate: number;      \u002F\u002F high-risk areas covered over time\n    sessionProductivity: number;    \u002F\u002F useful findings per session\n  };\n}\n\nfunction calculateExploratoryMetrics(sessions: ExploratorySession[]): ExploratoryMetrics {\n  const completedSessions = sessions.filter(s => s.status === 'completed');\n  const totalMinutes = completedSessions.reduce((sum, s) => sum + (s.actualDuration || 0), 0);\n  const totalHours = totalMinutes \u002F 60;\n  const allDefects = completedSessions.flatMap(s => s.defects);\n\n  const severityDist: Record\u003Cstring, number> = {};\n  for (const defect of allDefects) {\n    severityDist[defect.severity] = (severityDist[defect.severity] || 0) + 1;\n  }\n\n  const categoryDist: Record\u003Cstring, number> = {};\n  for (const defect of allDefects) {\n    categoryDist[defect.category] = (categoryDist[defect.category] || 0) + 1;\n  }\n\n  return {\n    period: {\n      start: completedSessions.length > 0 ? completedSessions[0].startTime : new Date(),\n      end: new Date(),\n    },\n    sessionMetrics: {\n      totalSessions: completedSessions.length,\n      totalHours: Math.round(totalHours * 10) \u002F 10,\n      averageSessionLength: completedSessions.length > 0\n        ? Math.round(totalMinutes \u002F completedSessions.length)\n        : 0,\n      charterCompletionRate: completedSessions.length > 0\n        ? Math.round(\n            (completedSessions.filter(s => s.coverageAreas.length > 0).length \u002F\n              completedSessions.length) * 100\n          )\n        : 0,\n    },\n    defectMetrics: {\n      totalDefects: allDefects.length,\n      defectsPerSession: completedSessions.length > 0\n        ? Math.round((allDefects.length \u002F completedSessions.length) * 10) \u002F 10\n        : 0,\n      defectsPerHour: totalHours > 0\n        ? Math.round((allDefects.length \u002F totalHours) * 10) \u002F 10\n        : 0,\n      severityDistribution: severityDist,\n      categoryDistribution: categoryDist,\n    },\n    coverageMetrics: {\n      totalAreas: 0,\n      exploredAreas: 0,\n      highRiskCoverage: 0,\n      averageDepth: 'moderate',\n    },\n    qualityIndicators: {\n      defectClusteringIndex: calculateClusteringIndex(completedSessions),\n      explorationEfficiency: totalHours > 0 ? allDefects.length \u002F totalHours : 0,\n      riskReductionRate: 0,\n      sessionProductivity: completedSessions.length > 0\n        ? completedSessions.reduce((sum, s) => sum + s.metrics.totalNotes, 0) \u002F completedSessions.length\n        : 0,\n    },\n  };\n}\n\nfunction calculateClusteringIndex(sessions: ExploratorySession[]): number {\n  const areaDefectCounts: Record\u003Cstring, number> = {};\n  for (const session of sessions) {\n    for (const area of session.coverageAreas) {\n      areaDefectCounts[area.name] = (areaDefectCounts[area.name] || 0) + area.defectsFound;\n    }\n  }\n  const counts = Object.values(areaDefectCounts);\n  if (counts.length === 0) return 0;\n  const max = Math.max(...counts);\n  const total = counts.reduce((a, b) => a + b, 0);\n  return total > 0 ? Math.round((max \u002F total) * 100) \u002F 100 : 0;\n}\n```\n\n## Configuration\n\n```typescript\n\u002F\u002F charter-config.ts\ninterface CharterConfig {\n  defaults: {\n    timeBoxMinutes: number;\n    setupPercentage: number;\n    explorationPercentage: number;\n    debriefPercentage: number;\n    breakReminderThreshold: number;\n  };\n  personas: TestPersona[];\n  heuristics: {\n    name: string;\n    description: string;\n    elements: string[];\n  }[];\n  riskThresholds: {\n    high: number;\n    medium: number;\n    low: number;\n  };\n  reportFormat: 'markdown' | 'json' | 'html';\n  screenshotDirectory: string;\n  noteAutoSaveInterval: number; \u002F\u002F seconds\n}\n\nconst defaultConfig: CharterConfig = {\n  defaults: {\n    timeBoxMinutes: 60,\n    setupPercentage: 10,\n    explorationPercentage: 75,\n    debriefPercentage: 15,\n    breakReminderThreshold: 60,\n  },\n  personas: [\n    { name: 'Novice User', description: 'First-time user with no domain knowledge', technicalLevel: 'novice', motivation: 'Complete a task with minimal guidance', commonActions: ['reading help text', 'clicking obvious buttons', 'making mistakes'] },\n    { name: 'Power User', description: 'Experienced user who knows shortcuts', technicalLevel: 'expert', motivation: 'Efficiency and speed', commonActions: ['keyboard shortcuts', 'batch operations', 'customization'] },\n    { name: 'Malicious User', description: 'User attempting to break or exploit the system', technicalLevel: 'expert', motivation: 'Finding vulnerabilities and bypasses', commonActions: ['injection attempts', 'parameter tampering', 'privilege escalation'] },\n    { name: 'Accessibility User', description: 'User relying on assistive technology', technicalLevel: 'intermediate', motivation: 'Using the product with screen reader or keyboard only', commonActions: ['tab navigation', 'screen reader interaction', 'high contrast mode'] },\n  ],\n  heuristics: [\n    { name: 'SFDIPOT', description: 'San Francisco Depot - Product element analysis', elements: ['Structure', 'Function', 'Data', 'Interfaces', 'Platform', 'Operations', 'Time'] },\n    { name: 'HICCUPPS', description: 'Consistency oracle heuristics', elements: ['History', 'Image', 'Comparable', 'Claims', 'User expectations', 'Product', 'Purpose', 'Standards'] },\n    { name: 'FEW HICCUPS', description: 'Extended consistency heuristics', elements: ['Familiarity', 'Explainability', 'World', 'History', 'Image', 'Comparable', 'Claims', 'User expectations', 'Product', 'Standards'] },\n    { name: 'Touring Heuristics', description: 'Tour-based exploration', elements: ['Guidebook tour', 'Money tour', 'Landmark tour', 'Intellectual tour', 'FedEx tour', 'Garbage collector tour', 'Bad neighborhood tour', 'Museum tour'] },\n  ],\n  riskThresholds: { high: 45, medium: 20, low: 0 },\n  reportFormat: 'markdown',\n  screenshotDirectory: '.\u002Ftest-artifacts\u002Fscreenshots',\n  noteAutoSaveInterval: 30,\n};\n```\n\n## Best Practices\n\n1. **Write the charter before the session** -- Crafting the charter is a design activity. Rushing it at session start wastes exploration time. Write charters during planning, not during testing.\n\n2. **Keep sessions between 45 and 90 minutes** -- Shorter sessions lack depth. Longer sessions cause fatigue and reduce defect detection rates. The sweet spot is 60 minutes of exploration with 15 minutes of debrief.\n\n3. **Use one persona per session** -- Switching personas mid-session splits focus. Assign a single persona to each charter and explore consistently through that lens.\n\n4. **Photograph or screenshot every anomaly immediately** -- Visual evidence degrades when you try to reproduce it later. Capture first, investigate second.\n\n5. **Separate observation from interpretation** -- Notes should say \"clicking Submit with empty form shows no error message\" not \"the form validation is broken.\" Record what you see, then analyze in the debrief.\n\n6. **Vary your test oracles across sessions** -- Do not rely on a single oracle (specification). Use history, comparable products, user expectations, and standards as alternative oracles in different sessions.\n\n7. **Track your own testing biases** -- If you always test the same browser, the same data, or the same path first, you create blind spots. Use randomization and heuristic rotation to counteract bias.\n\n8. **Debrief with someone else present** -- A solo debrief is a missed opportunity. Another tester asking \"why did you explore that area?\" forces articulation that reveals gaps and assumptions.\n\n9. **Feed session output into future charters** -- Questions, ideas, and untested areas from one session should directly generate charters for the next cycle. Exploration is iterative, not one-shot.\n\n10. **Maintain a living risk model** -- Update risk assessments after every session. Areas where defects cluster should have their risk scores increased. Areas that have been deeply explored without issues can be deprioritized.\n\n11. **Never skip the setup verification** -- Confirm your environment, data, and access are correct before the timer starts. Discovering a broken test environment 30 minutes into a session is a preventable waste.\n\n12. **Use touring heuristics for unfamiliar features** -- When you do not know a feature well, use the Guidebook Tour (follow the user manual) or the Landmark Tour (visit key capabilities) before attempting creative exploration.\n\n13. **Document what you did NOT test** -- The uncovered areas are as important as the covered ones. Explicitly listing what was not tested makes coverage gaps visible to the team.\n\n14. **Calibrate defect severity during debrief, not during exploration** -- During exploration, capture defects quickly with minimal classification. Refine severity and priority during the structured debrief when you have more context.\n\n## Anti-Patterns to Avoid\n\n1. **Aimless wandering** -- Exploring without a charter is not exploratory testing; it is procrastination. Every session must have a mission. Without a charter, you cannot measure whether you accomplished anything.\n\n2. **Over-scripting the session** -- If your charter specifies exact steps and expected results, you have written a test case, not a charter. Charters set direction; the tester's skill determines the path.\n\n3. **Ignoring the time box** -- Running sessions without a timer or consistently extending sessions \"just five more minutes\" destroys the discipline that makes SBTM work. Respect the boundary.\n\n4. **Treating exploratory testing as only manual clicking** -- Exploratory testing is a cognitive activity, not a click activity. It includes reading logs, querying databases, inspecting network traffic, and analyzing state. Limiting it to the UI limits its power.\n\n5. **Skipping debriefs** -- A session without a debrief produces findings that exist only in one tester's memory. Institutional knowledge requires documentation and sharing.\n\n6. **Confusing coverage breadth with testing quality** -- Touching every feature at a shallow level is worse than deeply exploring high-risk areas. Depth on risk-critical areas outweighs breadth on stable features.\n\n7. **Never rotating personas or heuristics** -- Using the same persona and the same heuristic in every session produces the same type of findings. Rotate systematically.\n\n8. **Filing zero defects as a success indicator** -- Zero defects from an exploratory session might mean the software is good, or it might mean the exploration was ineffective. Evaluate based on coverage depth and note quality, not defect counts alone.\n\n## Debugging Tips\n\n1. **Charter too vague to be actionable** -- If a charter says \"Explore the search feature to find bugs,\" it lacks specificity. Add constraints: which search filters, which data volumes, which user type, which error conditions. A charter should be narrow enough that another tester could pick it up and know exactly where to start.\n\n2. **Sessions consistently running over time** -- This usually means charters are scoped too broadly. Split large charters into smaller, focused ones. A charter covering \"the entire checkout flow\" should become three charters: cart management, payment processing, and order confirmation.\n\n3. **Low defect discovery rate** -- Check whether you are varying your approach enough. If every session uses the same data, same browser, same happy path, you will find diminishing returns. Apply different heuristics, use extreme data, and change the environment.\n\n4. **Notes too sparse to reproduce defects** -- Implement a structured note format with mandatory fields: timestamp, action, input data, expected result, actual result. Train testers to write notes as if someone else will read them.\n\n5. **Team not valuing exploratory sessions** -- Report metrics that management cares about: defects found per hour compared to scripted testing, unique defect categories discovered, risk coverage improvement. Show the return on investment with data.\n\n6. **Coverage map shows blind spots in the same areas repeatedly** -- This indicates a systemic bias. Assign those areas to a different tester, use a different heuristic, or create charters with a different persona to force a fresh perspective.\n\n7. **Debrief sessions feel unproductive** -- Structure them with a fixed agenda: charter review (2 minutes), top findings (5 minutes), coverage assessment (3 minutes), next actions (5 minutes). Time-box the debrief itself to prevent rambling.\n\n8. **Difficulty prioritizing charters** -- Use the risk matrix (probability times impact times frequency) to score every charter. Sort by score. When in doubt, prioritize charters targeting recently changed code, features with a history of defects, or areas where customer complaints have been reported.\n\n9. **Exploration becomes repetitive across sprint cycles** -- Introduce new touring heuristics each sprint. If you used SFDIPOT last sprint, use Touring Heuristics this sprint. Rotate the cognitive tools, not just the features.\n\n10. **Stakeholders question what was tested** -- Generate session reports that map exploration to product areas, include screenshots, and show risk coverage percentages. Exploratory testing is not less rigorous than scripted testing; it merely requires different documentation to prove its value.",{"name":5,"tags":24,"agents":33,"author":46,"domains":47,"license":15,"version":50,"languages":51,"frameworks":54,"description":7,"testingTypes":55},[25,26,27,28,29,30,31,32],"exploratory-testing","test-charter","session-based","risk-based","heuristics","test-notes","test-exploration","sbtm",[34,35,36,37,38,39,40,41,42,43,44,45],"claude-code","cursor","github-copilot","windsurf","codex","aider","continue","cline","zed","bolt","gemini-cli","amp","Pramod",[48,49],"web","api","1.0.0",[52,53],"typescript","javascript",[],[56],"e2e","main","eac438ea9216a7cb8a570cab803eb01eeafc6793","skills\u002Fqa\u002Fexploratory-test-charter-generator","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m","https:\u002F\u002Fid-preview--d5bef06d-6c9e-4563-a3d4-a855b9d61610.lovable.app\u002F","Eu sou Antonio B. B. Ndombe \r\nEu sou um Pesquisador e desenvolvedor de sistema autonomia cognitivos, fundador de sistemas ODCs ( organismos digital conscientes)","2026-11-04 06:53:39",{"source":8,"skillName":5,"commands":66,"prompt":76,"zipAvailable":77},[67,70,73],{"tool":68,"command":69},"npx","npx skills add GrupoANDevelopment-m\u002Falberto-ai --skill \"Exploratory Test Charter Generator\"",{"tool":71,"command":72},"bunx","bunx skills add GrupoANDevelopment-m\u002Falberto-ai --skill \"Exploratory Test Charter Generator\"",{"tool":74,"command":75},"pnpm","pnpm dlx skills add GrupoANDevelopment-m\u002Falberto-ai --skill \"Exploratory Test Charter Generator\"","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fskills\u002Fqa\u002Fexploratory-test-charter-generator\u002FSKILL.md",true,[],[80,88,95,102,109,116],{"skillNo":81,"name":82,"nameZh":6,"description":83,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":84,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":19},"01M7DASC6FSCJP49JZBSK0NY1Z","nemoclaw-user-reference","Describes the NemoClaw integration layer and blueprint architecture and how they orchestrate compatible agent sandboxes. Use when looking up architecture, agent integration, plugin structure, or blueprint design. Trigger keywords - nemoclaw architecture, nemoclaw agent architecture, nemoclaw plugin blueprint structure, nemoclaw vs openshell, which cli, nemoclaw cli, openshell cli, sandbox commands, nemoclaw cli commands, nemoclaw command reference, nemoclaw network policy, sandbox egress control operator approval, nemoclaw troubleshooting, nemoclaw debug sandbox issues.","Apache-2.0","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fupstream\u002Fnemoclaw\u002Fskills\u002Fnemoclaw-user-reference\u002FSKILL.md",[],[],{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":84,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":19},"01M7DAS5S79VK33XFGVAM2TFWF","nemoclaw-user-overview","Explains how OpenClaw, OpenShell, and NemoClaw form the ecosystem, NemoClaw's position in the stack, what NemoClaw adds beyond the community sandbox, and when to prefer NemoClaw versus integrating OpenShell and OpenClaw directly. Use when users ask about the relationship between OpenClaw, OpenShell, and NemoClaw, or when to use NemoClaw versus OpenShell. Trigger keywords - nemoclaw ecosystem, openclaw openshell, nemoclaw vs openshell, sandboxed openclaw, how nemoclaw works, nemoclaw sandbox lifecycle blueprint, nemoclaw overview, openclaw always-on assistants, nvidia openshell, nvidia nemotron, nemoclaw release notes, nemoclaw changelog.","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fupstream\u002Fnemoclaw\u002Fskills\u002Fnemoclaw-user-overview\u002FSKILL.md",[],[],{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":84,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":101,"publishedAt":19},"01M7DAS0PQEMET5MNGZ1ABSZVS","nemoclaw-user-monitor-sandbox","Inspects sandbox health, traces agent behavior, and diagnoses problems. Use when monitoring a running sandbox, debugging agent issues, or checking sandbox logs. Trigger keywords - monitor nemoclaw sandbox, debug nemoclaw agent issues.","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fupstream\u002Fnemoclaw\u002Fskills\u002Fnemoclaw-user-monitor-sandbox\u002FSKILL.md",[],[],{"skillNo":103,"name":104,"nameZh":6,"description":105,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":84,"licenseFileUrl":6,"sourceHtmlUrl":106,"categories":107,"keywords":108,"publishedAt":19},"01M7DARQYGF7E9A69VH6S3CGN9","nemoclaw-user-manage-sandboxes","Explains operational tasks after the quickstart: listing sandboxes, status and health checks, logs, diagnostics, port forwards, multiple sandboxes, credential reset, rebuilds, network presets, upgrades, and uninstall. Trigger keywords - manage nemoclaw sandboxes, nemoclaw status, nemoclaw list, nemoclaw dashboard port, nemoclaw rebuild, nemoclaw upgrade sandboxes, nemoclaw uninstall, sandbox mutability, sandbox runtime configuration, sandbox rebuild, nemoclaw backup, nemoclaw restore, workspace backup, openshell sandbox download upload, nemoclaw messaging channels, nemoclaw telegram, nemoclaw discord, nemoclaw slack, nemoclaw wechat, nemoclaw whatsapp, openshell channel messaging, nemoclaw workspace files, soul.md, user.md, identity.md, agents.md, sandbox persistence.","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fupstream\u002Fnemoclaw\u002Fskills\u002Fnemoclaw-user-manage-sandboxes\u002FSKILL.md",[],[],{"skillNo":110,"name":111,"nameZh":6,"description":112,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":84,"licenseFileUrl":6,"sourceHtmlUrl":113,"categories":114,"keywords":115,"publishedAt":19},"01M7DARH8BRTG51TRCAB7YWDJ4","nemoclaw-user-manage-policy","Adds, removes, or modifies allowed endpoints in the sandbox policy. Use when customizing network policy, changing egress rules, or configuring sandbox endpoint access. Trigger keywords - customize nemoclaw network policy, sandbox egress policy configuration, nemoclaw integration policy examples, post-install policy setup, openshell approval workflow, policy preset, nemoclaw approve network requests, sandbox egress approval tui.","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fupstream\u002Fnemoclaw\u002Fskills\u002Fnemoclaw-user-manage-policy\u002FSKILL.md",[],[],{"skillNo":117,"name":118,"nameZh":6,"description":119,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":84,"licenseFileUrl":6,"sourceHtmlUrl":120,"categories":121,"keywords":122,"publishedAt":19},"01M7DARAT62M2VR37590VCZ5NS","nemoclaw-user-get-started","Installs NemoClaw, launches a sandbox, and runs the first agent prompt. Use when onboarding, installing, or launching a NemoClaw sandbox for the first time. Trigger keywords - nemoclaw quickstart, install nemoclaw openclaw sandbox, nemohermes quickstart, hermes agent nemoclaw, run hermes openshell sandbox, nemoclaw prerequisites, nemoclaw supported platforms, nemoclaw hardware software, nemoclaw windows wsl2 setup, nemoclaw install windows docker desktop.","https:\u002F\u002Fgithub.com\u002FGrupoANDevelopment-m\u002Falberto-ai\u002Fblob\u002Fmain\u002Fupstream\u002Fnemoclaw\u002Fskills\u002Fnemoclaw-user-get-started\u002FSKILL.md",[],[]]