@goondocks/myco 0.1.0

package/dist/src/capture/prompts/exploration.md

@@ -0,0 +1,88 @@
+---
+name: exploration
+description: For sessions focused on reading/searching code
+activity_filter: Read,Grep,Glob
+min_activities: 3
+---
+
+You are analyzing an exploration/research session to extract useful learnings.
+
+## Context
+
+The developer was exploring the codebase to understand how things work.
+
+Duration: {{session_duration}} minutes
+Files explored: {{files_read}}
+
+### Search and Read Activity
+
+{{activities}}
+
+## Observation Types
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Task
+
+Extract observations about the codebase structure, patterns, or gotchas discovered during exploration.
+
+Focus on:
+- How specific features are implemented
+- Important patterns or conventions used
+- Non-obvious relationships between components
+- Things that surprised the developer
+
+Prefer **discovery** and **gotcha** types for exploration sessions.
+
+## Examples
+
+**Good observation** (non-obvious behavior — extract this):
+```json
+{
+  "type": "discovery",
+  "observation": "Env vars set in .claude/settings.json don't get shell expansion — tilde (~) paths must be expanded manually in code via os.homedir().",
+  "context": "src/vault/resolve.ts",
+  "importance": "high"
+}
+```
+
+**Bad observation** (obvious from code structure — skip this):
+```json
+{
+  "type": "discovery",
+  "observation": "The project has a src directory with TypeScript files",
+  "context": "src/",
+  "importance": "low"
+}
+```
+
+## Output Format
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "What was learned",
+      "context": "File or feature area",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "Brief description of what was explored"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+
+Respond ONLY with valid JSON.

package/dist/src/capture/prompts/extraction.md

@@ -0,0 +1,93 @@
+---
+name: extraction
+description: General observation extraction from session activities
+min_activities: 1
+---
+
+You are analyzing a coding session to extract important observations for future reference.
+
+## Session Activity
+
+Duration: {{session_duration}} minutes
+Files read: {{files_read}}
+Files modified: {{files_modified}}
+Files created: {{files_created}}
+Errors encountered: {{errors}}
+
+### Tool Executions
+
+{{activities}}
+
+## Observation Types
+
+Extract observations using these types:
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Session Context Awareness
+
+Consider the session's activity pattern when rating observation importance:
+
+- **Planning/investigation sessions** (many reads, few edits): Prefer lower importance ratings for observations that describe current problems or temporary state rather than permanent learnings.
+- **Implementation sessions** (significant edits): Observations about decisions made, patterns established, or gotchas encountered are more likely to be permanent learnings and may warrant higher importance.
+
+When in doubt, prefer a conservative (lower) importance rating.
+
+## Examples
+
+**Good observation** (specific, actionable):
+```json
+{
+  "type": "gotcha",
+  "observation": "SQLite WAL mode must be enabled before concurrent reads work. Without WAL, readers block writers and vice versa.",
+  "context": "src/index/sqlite.ts",
+  "importance": "high"
+}
+```
+
+**Bad observation** (too generic — skip this):
+```json
+{
+  "type": "discovery",
+  "observation": "The project uses SQLite for storage",
+  "context": "src/index",
+  "importance": "low"
+}
+```
+
+## Output Format
+
+Respond with a JSON object:
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "Concise description of what was learned",
+      "context": "Relevant file or feature name",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "One sentence describing what the session accomplished"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+- Only include genuinely useful observations that would help in future sessions
+- Be specific - mention file names, function names, actual values
+- If the session was just exploration without meaningful learnings, return empty observations
+- Focus on things that aren't obvious from the code itself
+
+Respond ONLY with valid JSON.

package/dist/src/capture/prompts/implementation.md

@@ -0,0 +1,90 @@
+---
+name: implementation
+description: For implementation sessions with writes/edits
+activity_filter: Write,Edit
+min_activities: 2
+---
+
+You are analyzing an implementation session to capture design decisions.
+
+## Context
+
+The developer was implementing a new feature or making significant changes.
+
+Duration: {{session_duration}} minutes
+Files created: {{files_created}}
+Files modified: {{files_modified}}
+
+### Implementation Activity
+
+{{activities}}
+
+## Observation Types
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Task
+
+Extract design decisions, architectural choices, and implementation gotchas.
+
+Focus on:
+- Why specific approaches were chosen
+- Trade-offs considered
+- Patterns followed or established
+- Edge cases handled
+- Integration points with existing code
+
+Prefer **decision**, **trade_off**, and **gotcha** types for implementation sessions.
+
+## Examples
+
+**Good observation** (clear rationale — extract this):
+```json
+{
+  "type": "decision",
+  "observation": "Chose plain tsc over tsup for build because native deps (better-sqlite3) can't be bundled. tsc preserves directory structure so relative imports work without path rewriting.",
+  "context": "package.json build config",
+  "importance": "medium"
+}
+```
+
+**Bad observation** (no rationale — skip this):
+```json
+{
+  "type": "decision",
+  "observation": "Used TypeScript for the project",
+  "context": "src/",
+  "importance": "low"
+}
+```
+
+## Output Format
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "Design choice and rationale",
+      "context": "Feature or component name",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "Brief description of what was implemented"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+
+Respond ONLY with valid JSON.

package/dist/src/capture/prompts/prompts/classify.md

@@ -0,0 +1,28 @@
+---
+name: classify
+description: Classify activity type for a single user request
+---
+
+Classify the type of work done in response to a single user request.
+
+## Activity Summary
+
+- Duration: {{session_duration}} minutes
+- Tools used: {{tool_summary}}
+- Files read: {{files_read_count}}
+- Files modified: {{files_modified_count}}
+- Files created: {{files_created_count}}
+- Errors encountered: {{has_errors}}
+
+## Activity Log
+
+{{activities}}
+
+## Classification Types
+
+{{classification_types}}
+
+## Task
+
+Based on the activities above, determine what the agent was primarily doing.
+Respond with ONLY the classification word (e.g., exploration, debugging, implementation, refactoring), nothing else.

package/dist/src/capture/prompts/prompts/debugging.md

@@ -0,0 +1,91 @@
+---
+name: debugging
+description: For debugging sessions with errors
+activity_filter: Read,Edit,Bash
+min_activities: 2
+---
+
+You are analyzing a debugging session to capture the root cause and fix.
+
+## Context
+
+The developer was debugging an issue.
+
+Duration: {{session_duration}} minutes
+Files investigated: {{files_read}}
+Files modified: {{files_modified}}
+Errors: {{errors}}
+
+### Debugging Activity
+
+{{activities}}
+
+## Observation Types
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Task
+
+Extract the debugging journey: what was the symptom, what was investigated, what was the root cause, and how was it fixed.
+
+Focus on:
+- The initial error or symptom
+- Wrong assumptions or dead ends
+- The actual root cause
+- The fix and why it works
+- How to avoid this in the future
+
+Prefer **bug_fix** and **gotcha** types for debugging sessions.
+
+## Examples
+
+**Good observation** (specific root cause and fix — extract this):
+```json
+{
+  "type": "bug_fix",
+  "observation": "SQLite LIMIT clause was string-interpolated, allowing SQL injection. Fix: use parameterized query with LIMIT ? and push value to params array.",
+  "context": "src/index/sqlite.ts",
+  "importance": "high"
+}
+```
+
+**Bad observation** (too vague — skip this):
+```json
+{
+  "type": "bug_fix",
+  "observation": "Fixed a database error",
+  "context": "src/index",
+  "importance": "medium"
+}
+```
+
+## Output Format
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "Root cause and fix description",
+      "context": "File where bug was",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "Brief description of bug and fix"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+
+Respond ONLY with valid JSON.

package/dist/src/capture/prompts/prompts/exploration.md

@@ -0,0 +1,88 @@
+---
+name: exploration
+description: For sessions focused on reading/searching code
+activity_filter: Read,Grep,Glob
+min_activities: 3
+---
+
+You are analyzing an exploration/research session to extract useful learnings.
+
+## Context
+
+The developer was exploring the codebase to understand how things work.
+
+Duration: {{session_duration}} minutes
+Files explored: {{files_read}}
+
+### Search and Read Activity
+
+{{activities}}
+
+## Observation Types
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Task
+
+Extract observations about the codebase structure, patterns, or gotchas discovered during exploration.
+
+Focus on:
+- How specific features are implemented
+- Important patterns or conventions used
+- Non-obvious relationships between components
+- Things that surprised the developer
+
+Prefer **discovery** and **gotcha** types for exploration sessions.
+
+## Examples
+
+**Good observation** (non-obvious behavior — extract this):
+```json
+{
+  "type": "discovery",
+  "observation": "Env vars set in .claude/settings.json don't get shell expansion — tilde (~) paths must be expanded manually in code via os.homedir().",
+  "context": "src/vault/resolve.ts",
+  "importance": "high"
+}
+```
+
+**Bad observation** (obvious from code structure — skip this):
+```json
+{
+  "type": "discovery",
+  "observation": "The project has a src directory with TypeScript files",
+  "context": "src/",
+  "importance": "low"
+}
+```
+
+## Output Format
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "What was learned",
+      "context": "File or feature area",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "Brief description of what was explored"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+
+Respond ONLY with valid JSON.

package/dist/src/capture/prompts/prompts/extraction.md

@@ -0,0 +1,93 @@
+---
+name: extraction
+description: General observation extraction from session activities
+min_activities: 1
+---
+
+You are analyzing a coding session to extract important observations for future reference.
+
+## Session Activity
+
+Duration: {{session_duration}} minutes
+Files read: {{files_read}}
+Files modified: {{files_modified}}
+Files created: {{files_created}}
+Errors encountered: {{errors}}
+
+### Tool Executions
+
+{{activities}}
+
+## Observation Types
+
+Extract observations using these types:
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Session Context Awareness
+
+Consider the session's activity pattern when rating observation importance:
+
+- **Planning/investigation sessions** (many reads, few edits): Prefer lower importance ratings for observations that describe current problems or temporary state rather than permanent learnings.
+- **Implementation sessions** (significant edits): Observations about decisions made, patterns established, or gotchas encountered are more likely to be permanent learnings and may warrant higher importance.
+
+When in doubt, prefer a conservative (lower) importance rating.
+
+## Examples
+
+**Good observation** (specific, actionable):
+```json
+{
+  "type": "gotcha",
+  "observation": "SQLite WAL mode must be enabled before concurrent reads work. Without WAL, readers block writers and vice versa.",
+  "context": "src/index/sqlite.ts",
+  "importance": "high"
+}
+```
+
+**Bad observation** (too generic — skip this):
+```json
+{
+  "type": "discovery",
+  "observation": "The project uses SQLite for storage",
+  "context": "src/index",
+  "importance": "low"
+}
+```
+
+## Output Format
+
+Respond with a JSON object:
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "Concise description of what was learned",
+      "context": "Relevant file or feature name",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "One sentence describing what the session accomplished"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+- Only include genuinely useful observations that would help in future sessions
+- Be specific - mention file names, function names, actual values
+- If the session was just exploration without meaningful learnings, return empty observations
+- Focus on things that aren't obvious from the code itself
+
+Respond ONLY with valid JSON.

package/dist/src/capture/prompts/prompts/implementation.md

@@ -0,0 +1,90 @@
+---
+name: implementation
+description: For implementation sessions with writes/edits
+activity_filter: Write,Edit
+min_activities: 2
+---
+
+You are analyzing an implementation session to capture design decisions.
+
+## Context
+
+The developer was implementing a new feature or making significant changes.
+
+Duration: {{session_duration}} minutes
+Files created: {{files_created}}
+Files modified: {{files_modified}}
+
+### Implementation Activity
+
+{{activities}}
+
+## Observation Types
+
+{{observation_types}}
+
+## Importance Levels
+
+Rate each observation's importance based on its value for future sessions:
+
+- **high**: Non-obvious insight that would cause bugs, confusion, or wasted time if forgotten. Cannot be easily rediscovered from code alone.
+- **medium**: Useful context that saves time but could be rediscovered with investigation.
+- **low**: Nice-to-know information that is easily found from code or already documented elsewhere. Skip if already captured in project docs.
+
+Prefer fewer high-quality observations over many low-importance ones.
+
+## Task
+
+Extract design decisions, architectural choices, and implementation gotchas.
+
+Focus on:
+- Why specific approaches were chosen
+- Trade-offs considered
+- Patterns followed or established
+- Edge cases handled
+- Integration points with existing code
+
+Prefer **decision**, **trade_off**, and **gotcha** types for implementation sessions.
+
+## Examples
+
+**Good observation** (clear rationale — extract this):
+```json
+{
+  "type": "decision",
+  "observation": "Chose plain tsc over tsup for build because native deps (better-sqlite3) can't be bundled. tsc preserves directory structure so relative imports work without path rewriting.",
+  "context": "package.json build config",
+  "importance": "medium"
+}
+```
+
+**Bad observation** (no rationale — skip this):
+```json
+{
+  "type": "decision",
+  "observation": "Used TypeScript for the project",
+  "context": "src/",
+  "importance": "low"
+}
+```
+
+## Output Format
+
+```json
+{
+  "observations": [
+    {
+      "type": "{{type_names}}",
+      "observation": "Design choice and rationale",
+      "context": "Feature or component name",
+      "importance": "high|medium|low"
+    }
+  ],
+  "summary": "Brief description of what was implemented"
+}
+```
+
+Guidelines:
+- Extract at most 5 observations per session. Prefer fewer, higher-quality observations over many low-value ones.
+
+Respond ONLY with valid JSON.