jumpstart-mode 1.1.13 → 1.1.14

package/bin/lib/integrate.js

@@ -27,6 +27,7 @@ const SKILLS_DIR = '.jumpstart/skills';
 const INSTALLED_FILE = '.jumpstart/installed.json';
 const INTEGRATION_LOG = '.jumpstart/integration-log.json';
 const SKILL_INDEX_FILE = '.jumpstart/skills/skill-index.md';
+const SKILL_MAP_FILE = '.jumpstart/skills/skill-map.md';
 const IDE_INSTRUCTIONS_VSCODE = '.github/instructions/skills.instructions.md';
 const IDE_INSTRUCTIONS_GENERIC = '.jumpstart/instructions/skills.instructions.md';
 
@@ -308,6 +309,256 @@ All phase and advisory agents follow this protocol when \`skills.enabled\` is \`
   return { filePath: SKILL_INDEX_FILE, content };
 }
 
+// ─── Skill Map Generator ────────────────────────────────────────────────────
+
+/**
+ * Agent-to-skill affinity definitions.
+ * Each key is an agent identifier; value is an array of { skill, context } objects.
+ * Skills listed here are matched by name against installed skills.
+ */
+const AGENT_SKILL_AFFINITIES = {
+  'Scout': [
+    { skill: 'acquire-codebase-knowledge', context: 'Codebase mapping & structure discovery' },
+    { skill: 'architecture-blueprint-generator', context: 'C4 diagram generation' },
+  ],
+  'Challenger': [
+    { skill: 'bias-and-anti-pattern-checker', context: 'Anti-pattern & AI-hype detection' },
+    { skill: 'task-clarifier', context: 'Problem decomposition' },
+    { skill: 'discovery-depth-scorecard', context: 'Discovery completeness scoring' },
+  ],
+  'Analyst': [
+    { skill: 'user-persona-development', context: 'Persona creation' },
+    { skill: 'persona-journey-map-companion', context: 'Journey mapping' },
+    { skill: 'use-case-prioritization', context: 'Scope prioritization' },
+    { skill: 'success-metrics-designer', context: 'KPI framework' },
+    { skill: 'business-logic-extractor', context: 'Workflow extraction (brownfield)' },
+    { skill: 'discovery-depth-scorecard', context: 'Discovery verification' },
+    { skill: 'persona-empathy-map', context: 'Empathy mapping' },
+    { skill: 'current-state-process-miner', context: 'Process discovery' },
+    { skill: 'ai-use-case-readiness-assessor', context: 'Use case readiness' },
+    { skill: 'use-case-canvas-builder', context: 'Use case canvases' },
+  ],
+  'PM': [
+    { skill: 'acceptance-test-author', context: 'BDD/Gherkin scenarios' },
+    { skill: 'non-functional-requirements-elicitor', context: 'NFR elicitation' },
+    { skill: 'success-metrics-designer', context: 'Measurable KPIs' },
+    { skill: 'dependency-bottleneck-detector', context: 'Blocker detection' },
+    { skill: 'use-case-prioritization', context: 'Story prioritization' },
+    { skill: 'scope-creep-detector', context: 'Scope boundary validation' },
+    { skill: 'bottom-up-estimation', context: 'Effort estimation' },
+    { skill: 'impediment-prioritization', context: 'Blocker triage' },
+  ],
+  'Architect': [
+    { skill: 'architecture-blueprint-generator', context: 'C4 diagrams' },
+    { skill: 'mcp-server-designer', context: 'MCP tool surface' },
+    { skill: 'rag-architecture-designer', context: 'RAG pipeline' },
+    { skill: 'memory-architecture-designer', context: 'Agent memory' },
+    { skill: 'postgresql-pgvector', context: 'Vector DB schema' },
+    { skill: 'red-team-playbook-builder', context: 'AI security' },
+    { skill: 'tool-differentiation', context: 'Technology comparison' },
+    { skill: 'agent-approval-policy-spec', context: 'Approval policies' },
+    { skill: 'reference-architecture-snapshotter', context: 'Reference arch' },
+    { skill: 'azure-architecture-autopilot', context: 'Azure design' },
+    { skill: 'cloud-design-patterns', context: 'Cloud patterns' },
+    { skill: 'api-creator', context: 'API contract design' },
+    { skill: 'api-contract-test-generator', context: 'Contract tests' },
+    { skill: 'observability-design-for-ai', context: 'AI observability' },
+    { skill: 'privacy-by-design-for-ai', context: 'Privacy controls' },
+    { skill: 'agent-workflow-state-machine', context: 'Agent workflows' },
+    { skill: 'ai-cost-model-designer', context: 'Cost modelling' },
+    { skill: 'integration-surface-mapper', context: 'Integration mapping' },
+  ],
+  'Developer': [
+    { skill: 'dotnet-developer', context: '.NET implementation' },
+    { skill: 'python-developer', context: 'Python implementation' },
+    { skill: 'react-developer', context: 'React implementation' },
+    { skill: 'php-developer', context: 'PHP implementation' },
+    { skill: 'vuejs-developer', context: 'Vue.js implementation' },
+    { skill: 'acceptance-test-author', context: 'BDD test generation' },
+    { skill: 'design-md-auditor', context: 'UI compliance' },
+    { skill: 'design-token-sync', context: 'Design tokens' },
+    { skill: 'devops-rollout-plan', context: 'Deployment planning' },
+    { skill: 'xlsx', context: 'Spreadsheet operations' },
+    { skill: 'langfuse', context: 'AI observability' },
+    { skill: 'copilot-sdk', context: 'Copilot SDK' },
+    { skill: 'skill-creator', context: 'Skill creation' },
+    { skill: 'api-creator', context: 'API scaffolding' },
+    { skill: 'api-contract-test-generator', context: 'Contract tests' },
+    { skill: 'agent-customization', context: 'Agent files' },
+  ],
+  'QA': [
+    { skill: 'acceptance-test-author', context: 'BDD scenarios' },
+    { skill: 'api-contract-test-generator', context: 'Contract tests' },
+    { skill: 'grill-me', context: 'Criteria challenge' },
+  ],
+  'Security': [
+    { skill: 'red-team-playbook-builder', context: 'Red team playbooks' },
+    { skill: 'privacy-by-design-for-ai', context: 'Privacy assessment' },
+    { skill: 'agent-approval-policy-spec', context: 'Approval policies' },
+  ],
+  'Performance': [
+    { skill: 'non-functional-requirements-elicitor', context: 'NFR quantification' },
+    { skill: 'ai-cost-model-designer', context: 'Cost modelling' },
+    { skill: 'observability-design-for-ai', context: 'Observability' },
+  ],
+  'DevOps': [
+    { skill: 'devops-rollout-plan', context: 'Rollout plans' },
+    { skill: 'azure-architecture-autopilot', context: 'Azure infra' },
+    { skill: 'pre-deployment-gotcha-review', context: 'Pre-deploy checks' },
+    { skill: 'dora-evaluation-report', context: 'DORA metrics' },
+  ],
+  'UI/UX Designer': [
+    { skill: 'design-md-creator', context: 'DESIGN.md creation' },
+    { skill: 'design-md-auditor', context: 'Design compliance' },
+    { skill: 'design-token-sync', context: 'Token derivation' },
+    { skill: 'stitch-screen-to-design-md', context: 'Screen mapping' },
+  ],
+  'Researcher': [
+    { skill: 'tool-differentiation', context: 'Tech comparison' },
+    { skill: 'company-research', context: 'Vendor research' },
+  ],
+  'Scrum Master': [
+    { skill: 'bottom-up-estimation', context: 'Estimation' },
+    { skill: 'impediment-prioritization', context: 'Blocker triage' },
+    { skill: 'work-breakdown-builder', context: 'WBS' },
+    { skill: 'dependency-bottleneck-detector', context: 'Dependencies' },
+  ],
+  'Quick Dev': [
+    { skill: 'dotnet-developer', context: '.NET patterns' },
+    { skill: 'python-developer', context: 'Python patterns' },
+    { skill: 'react-developer', context: 'React patterns' },
+    { skill: 'vuejs-developer', context: 'Vue patterns' },
+    { skill: 'agent-customization', context: 'Agent files' },
+  ],
+  'Maintenance': [
+    { skill: 'scope-creep-detector', context: 'Drift detection' },
+    { skill: 'dora-evaluation-report', context: 'Health metrics' },
+    { skill: 'dependency-bottleneck-detector', context: 'Dependency health' },
+  ],
+  'Adversary': [
+    { skill: 'bias-and-anti-pattern-checker', context: 'Anti-patterns' },
+    { skill: 'scope-creep-detector', context: 'Scope validation' },
+    { skill: 'red-team-playbook-builder', context: 'Attack surface' },
+  ],
+  'Refactor': [
+    { skill: 'code-tour', context: 'Code navigation' },
+    { skill: 'architecture-blueprint-generator', context: 'Architecture alignment' },
+  ],
+  'Requirements Extractor': [
+    { skill: 'business-logic-extractor', context: 'Business logic' },
+    { skill: 'non-functional-requirements-elicitor', context: 'NFR gaps' },
+    { skill: 'ai-use-case-readiness-assessor', context: 'Readiness check' },
+  ],
+  'Retrospective': [
+    { skill: 'dora-evaluation-report', context: 'DORA analysis' },
+    { skill: 'scope-creep-detector', context: 'Scope growth' },
+    { skill: 'bottom-up-estimation', context: 'Estimation review' },
+  ],
+  'Reviewer': [
+    { skill: 'bias-and-anti-pattern-checker', context: 'Quality audit' },
+    { skill: 'scope-creep-detector', context: 'Scope adherence' },
+  ],
+  'Tech Writer': [
+    { skill: 'code-tour', context: 'Code tours' },
+    { skill: 'skill-creator', context: 'README structure' },
+  ],
+};
+
+/**
+ * Generate the agent-skill map (.jumpstart/skills/skill-map.md).
+ * Shows which installed skills map to which agents, auto-updated on integration.
+ *
+ * @param {object[]} skills - Scanned skill catalog (from scanInstalledSkills).
+ * @returns {{ filePath: string, content: string } | null}
+ */
+export function generateSkillMap(skills) {
+  if (skills.length === 0) return null;
+
+  const generatedAt = new Date().toISOString();
+  const installedNames = new Set(skills.map(s => s.id.replace('skill.', '')));
+
+  // Build agent → installed skills mapping
+  const agentSections = [];
+  for (const [agent, affinities] of Object.entries(AGENT_SKILL_AFFINITIES)) {
+    const matched = affinities.filter(a => installedNames.has(a.skill));
+    const unmatched = affinities.filter(a => !installedNames.has(a.skill));
+
+    if (matched.length === 0 && unmatched.length === 0) continue;
+
+    let section = `### ${agent}\n\n`;
+    if (matched.length > 0) {
+      section += `| Skill | Context | Status |\n|---|---|---|\n`;
+      for (const m of matched) {
+        section += `| \`${m.skill}\` | ${m.context} | ✅ Installed |\n`;
+      }
+      for (const u of unmatched) {
+        section += `| \`${u.skill}\` | ${u.context} | ⬜ Not installed |\n`;
+      }
+    } else {
+      section += `No mapped skills currently installed. Candidates:\n`;
+      for (const u of unmatched) {
+        section += `- \`${u.skill}\` — ${u.context}\n`;
+      }
+    }
+    agentSections.push(section);
+  }
+
+  // Build skill → agents reverse mapping
+  const skillToAgents = {};
+  for (const [agent, affinities] of Object.entries(AGENT_SKILL_AFFINITIES)) {
+    for (const a of affinities) {
+      if (!skillToAgents[a.skill]) skillToAgents[a.skill] = [];
+      skillToAgents[a.skill].push({ agent, context: a.context });
+    }
+  }
+
+  const reverseRows = skills.map(s => {
+    const name = s.id.replace('skill.', '');
+    const agents = skillToAgents[name] || [];
+    const agentList = agents.map(a => `${a.agent}`).join(', ') || '—';
+    return `| \`${name}\` | ${s.displayName} | ${agentList} |`;
+  });
+
+  const content = `# Skill Map — Agent-Skill Relationships
+
+> **Auto-generated** by \`jumpstart-mode integrate\` on ${generatedAt}.
+> Do NOT edit manually. Regenerate with: \`npx jumpstart-mode integrate\`
+
+## Summary
+
+- **Installed skills:** ${skills.length}
+- **Agents with skill mappings:** ${Object.keys(AGENT_SKILL_AFFINITIES).length}
+- **Active delegations:** ${Object.entries(AGENT_SKILL_AFFINITIES).reduce((acc, [, affs]) => acc + affs.filter(a => installedNames.has(a.skill)).length, 0)}
+
+## Skill → Agent (Reverse Lookup)
+
+Which agents use each installed skill:
+
+| Skill | Display Name | Used By Agents |
+|---|---|---|
+${reverseRows.join('\n')}
+
+## Agent → Skill (Forward Lookup)
+
+Which skills each agent can delegate to:
+
+${agentSections.join('\n')}
+
+## How This File Is Used
+
+1. **Agents** reference this map during their Skill Discovery protocol step to identify which installed skills they can delegate to.
+2. **The \`skill-context-injector\` hook** uses this map to proactively suggest skills during file edits.
+3. **Humans** use this map to understand skill coverage gaps and decide which marketplace skills to install.
+
+## Extending the Map
+
+When new skills are installed (\`npx jumpstart-mode install <skill>\`), this file regenerates automatically.
+To add a new agent-skill affinity, update the \`AGENT_SKILL_AFFINITIES\` constant in \`bin/lib/integrate.js\`.
+`;
+
+  return { filePath: SKILL_MAP_FILE, content };
+}
+
 // ─── Integration Log ────────────────────────────────────────────────────────
 
 /**
@@ -407,6 +658,16 @@ export function applyIntegration(projectRoot, options = {}) {
     progress(`  ✓ ${indexResult.filePath}`);
   }
 
+  // Generate skill map (agent-skill relationships)
+  const mapResult = generateSkillMap(skills);
+  if (mapResult) {
+    const abs = path.resolve(projectRoot, mapResult.filePath);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, mapResult.content, 'utf8');
+    filesWritten.push(mapResult.filePath);
+    progress(`  ✓ ${mapResult.filePath}`);
+  }
+
   // Remove any previously generated files that we didn't just regenerate
   const currentFiles = new Set(filesWritten);
   for (const relPath of Object.keys(prevLog.files || {})) {

package/bin/lib/quickstart.js

@@ -87,6 +87,8 @@ export function buildQuickstartConfig(answers = {}) {
     approverName: answers.approverName || null,
     projectType: answers.projectType || 'greenfield',
     copilot: true, // Enable Copilot integration by default in quickstart
+    copilotObservability: false,
+    runCopilotObservability: false,
     force: false,
     dryRun: false,
     interactive: false,

package/copilot-observability/README.md

@@ -0,0 +1,226 @@
+# Personal Copilot Usage Observability
+
+This folder contains a local-first GitHub Copilot Chat OpenTelemetry usage tracker and dashboard for personal Copilot Pro / Pro+ workflows.
+
+It is designed to answer questions such as:
+
+- How many Copilot Chat prompts and sessions am I creating?
+- Which repositories and modes generate the most activity?
+- Which models consume the most tokens?
+- Which agent sessions run the most tools or fail most often?
+- Which prompt and response patterns are useful versus noisy?
+
+The dashboard is a local observability tool. It is not an official GitHub billing ledger.
+
+## Privacy posture
+
+Copilot Chat telemetry can contain sensitive data when content capture is enabled. Treat raw telemetry as private source data.
+
+Recommended controls:
+
+1. Enable `captureContent` only on trusted machines and only for intentional measurement windows.
+2. Store raw JSONL files in a local private folder that is not synced to shared cloud drives.
+3. Use full-disk encryption.
+4. Restrict telemetry folder permissions to your user account.
+5. Redact before ingestion using `config/redaction-rules.yml`.
+6. Delete or archive raw JSONL files with `scripts/apply_retention.py`.
+7. Avoid capturing regulated, client-confidential, or secret-heavy repositories.
+
+## Folder layout
+
+```text
+copilot-observability/
+  config/redaction-rules.yml       # Regex redaction rules
+  data/raw/                        # Local JSONL telemetry input (gitignored by .gitkeep only)
+  data/processed/                  # SQLite database output
+  dashboard/app.py                 # Streamlit dashboard
+  exports/                         # CSV exports
+  scripts/ingest_otel.py           # JSONL -> SQLite normalizer
+  scripts/redact.py                # Redaction helpers
+  scripts/rebuild_daily_usage.py   # Daily aggregate refresh
+  scripts/rate_session.py          # CLI rating helper
+  scripts/export_csv.py            # CSV export helper
+  scripts/apply_retention.py       # Raw-file retention helper
+  sql/schema.sql                   # SQLite schema
+  tests/                           # Python unit tests and sample telemetry
+```
+
+## VS Code settings example
+
+Use a private path on your machine. Keep `captureContent` disabled unless you explicitly want prompt/response capture.
+
+```json
+{
+  "github.copilot.chat.otel.enabled": true,
+  "github.copilot.chat.otel.exporterType": "file",
+  "github.copilot.chat.otel.outfile": "/home/yourname/.copilot-observability/raw/copilot-otel.jsonl",
+  "github.copilot.chat.otel.captureContent": false
+}
+```
+
+If you enable content capture, assume prompts, responses, referenced code, tool arguments, file paths, and nearby context may appear in the raw file.
+
+## Local directory permissions
+
+macOS / Linux:
+
+```bash
+mkdir -p ~/.copilot-observability/raw
+chmod 700 ~/.copilot-observability
+chmod 700 ~/.copilot-observability/raw
+```
+
+Windows PowerShell:
+
+```powershell
+New-Item -ItemType Directory -Force "$env:USERPROFILE\.copilot-observability\raw"
+icacls "$env:USERPROFILE\.copilot-observability" /inheritance:r
+icacls "$env:USERPROFILE\.copilot-observability" /grant:r "$env:USERNAME:(OI)(CI)F"
+```
+
+## Install dashboard dependencies
+
+From this folder:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+On Windows, activate with `.venv\Scripts\Activate.ps1`.
+
+## Ingest telemetry
+
+```bash
+python scripts/ingest_otel.py \
+  --input data/raw/copilot-otel.jsonl \
+  --db data/processed/copilot_usage.sqlite
+```
+
+The ingester accepts OpenTelemetry `resourceSpans` JSONL and direct span-like JSON records. It extracts:
+
+- sessions and trace IDs
+- timestamps and durations
+- workspace and hashed repository paths
+- mode classification (`ask`, `edit`, `agent`, `plan`, or `unknown`)
+- model and provider names when emitted
+- input, output, and cached token counts when emitted
+- prompt and response content when emitted
+- tool calls, status, and errors
+
+Records are inserted idempotently using deterministic IDs derived from span IDs.
+
+## Run the dashboard
+
+```bash
+streamlit run dashboard/app.py
+```
+
+Dashboard pages:
+
+1. Executive Summary
+2. Usage Trends
+3. Token and Cost Proxy
+4. Model Usage
+5. Prompt Explorer
+6. Agent Behavior
+7. Quality Tracking
+
+## Dashboard screenshots
+
+The screenshots below use safe sample telemetry and synthetic rows, not real personal Copilot content.
+
+### Executive Summary
+
+![Executive Summary dashboard](docs/images/executive-summary.png)
+
+### Prompt Explorer
+
+![Prompt Explorer dashboard](docs/images/prompt-explorer.png)
+
+### Quality Tracking
+
+![Quality Tracking dashboard](docs/images/quality-tracking.png)
+
+## Rate sessions
+
+Use the dashboard Quality Tracking page or the CLI:
+
+```bash
+python scripts/rate_session.py \
+  --db data/processed/copilot_usage.sqlite \
+  --session-id SESSION_ID \
+  --rating 4 \
+  --outcome "Accepted with edits" \
+  --notes "Useful implementation, minor cleanup needed"
+```
+
+Supported outcomes:
+
+- Accepted as-is
+- Accepted with edits
+- Useful explanation
+- Wrong direction
+- Too verbose
+- Hallucinated
+- Failed tool execution
+- Security concern
+- Abandoned
+
+## Export CSVs
+
+```bash
+python scripts/export_csv.py \
+  --db data/processed/copilot_usage.sqlite \
+  --output-dir exports
+```
+
+## Retention
+
+Delete raw JSONL files older than 14 days:
+
+```bash
+python scripts/apply_retention.py --raw-dir data/raw --days 14
+```
+
+Preview deletions first:
+
+```bash
+python scripts/apply_retention.py --raw-dir data/raw --days 14 --dry-run
+```
+
+## Cost proxy
+
+`model_rates` stores local placeholder token rates:
+
+```sql
+INSERT OR REPLACE INTO model_rates (
+  model, input_token_rate, output_token_rate, cached_token_rate, effective_date
+) VALUES (
+  'gpt-4.1', 0.0, 0.0, 0.0, '2026-04-28'
+);
+```
+
+The dashboard calculates:
+
+```text
+estimated_cost =
+  input_tokens * input_token_rate +
+  output_tokens * output_token_rate +
+  cached_tokens * cached_token_rate
+```
+
+This is an estimated local cost proxy, not official GitHub billing.
+
+## Tests
+
+From the repository root:
+
+```bash
+python -m unittest discover -s copilot-observability/tests
+```
+
+## Limitations
+
+This can track local Copilot Chat telemetry fields that are emitted to the configured OpenTelemetry file. It may not reliably track official billing totals, premium request accounting, inline completion accept/reject rates, enterprise metrics, or true time saved.

package/copilot-observability/config/redaction-rules.yml

@@ -0,0 +1,19 @@
+redactions:
+  - name: openai_key
+    pattern: "sk-[A-Za-z0-9_-]{20,}"
+    replacement: "[REDACTED_OPENAI_KEY]"
+  - name: github_token
+    pattern: "gh[pousr]_[A-Za-z0-9_]{20,}"
+    replacement: "[REDACTED_GITHUB_TOKEN]"
+  - name: azure_key
+    pattern: "(?i)(azure|api)[_-]?key\\s*[:=]\\s*[A-Za-z0-9+/=_-]{20,}"
+    replacement: "[REDACTED_API_KEY]"
+  - name: generic_password
+    pattern: "(?i)(password|passwd|pwd)\\s*[:=]\\s*[^\\s;]+"
+    replacement: "\\1=[REDACTED_PASSWORD]"
+  - name: connection_string
+    pattern: "(?i)(Server|Host|Data Source)=.*?(;|$)"
+    replacement: "[REDACTED_CONNECTION_STRING]"
+  - name: email
+    pattern: "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
+    replacement: "[REDACTED_EMAIL]"