@actrun_ai/tastekit-core 0.1.0

package/dist/domains/development-agent/skills/debugging-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugging-issues.d.ts","sourceRoot":"","sources":["../../../../domains/development-agent/skills/debugging-issues.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;CAsJhC,CAAC"}

package/dist/domains/development-agent/skills/debugging-issues.js

@@ -0,0 +1,155 @@
+/**
+ * Debugging Issues Skill
+ *
+ * Systematic debugging with root cause investigation.
+ */
+export const DebuggingIssuesSkill = {
+    skill_id: 'debugging-issues',
+    name: 'Debugging Issues',
+    description: 'Systematically investigates bugs and failures to find root causes before proposing fixes. Use when debugging errors, investigating test failures, diagnosing unexpected behavior, or when the user asks to fix a bug, debug, or investigate an issue.',
+    tags: ['development', 'debugging', 'investigation'],
+    risk_level: 'low',
+    required_tools: ['file-system'],
+    compatible_runtimes: ['claude-code', 'openclaw', 'manus'],
+    feeds_into: ['writing-tests'],
+    pipeline_phase: 'process',
+    context_model: 'inherit',
+    skill_md_content: `# Debugging Issues
+
+## Purpose
+
+Systematically investigates bugs and failures to find root causes. No fixes until the root cause is understood.
+
+## When to use
+
+- Investigating error messages or stack traces
+- Diagnosing test failures
+- Understanding unexpected behavior
+- When the user says "fix this bug", "why is this broken", or "debug this"
+
+## When NOT to use
+
+- For code review (use code-review skill)
+- For writing new features (not a debugging task)
+- When the fix is obvious and doesn't need investigation
+
+## Inputs
+
+- **symptom**: Error message, failing test, or description of unexpected behavior
+- **context**: When it started, what changed recently, reproduction steps
+- **scope**: Where to look (file paths, modules, or "unknown")
+
+## Outputs
+
+- **root_cause**: Clear explanation of why the bug happens
+- **evidence**: Specific code paths, line numbers, and data flow that prove the cause
+- **fix_recommendation**: Proposed fix with confidence level
+- **regression_test**: Test case that would catch this bug
+
+## Procedure
+
+### Step 1: Reproduce and observe
+
+- Confirm the bug is reproducible
+- Note the exact error, stack trace, or unexpected output
+- Identify what the correct behavior should be
+
+### Step 2: Form hypotheses
+
+- List 2-3 most likely causes based on the symptom
+- Rank by probability
+- Identify what evidence would confirm or eliminate each
+
+### Step 3: Investigate systematically
+
+- Start with the most likely hypothesis
+- Trace the code path from input to failure point
+- Check recent changes (git log, git blame) near the failure
+- Look for related issues (same pattern elsewhere?)
+
+### Step 4: Confirm root cause
+
+- Identify the exact line(s) causing the issue
+- Explain the causal chain: input -> code path -> failure
+- Verify this explains ALL observed symptoms, not just some
+
+### Step 5: Recommend fix
+
+- Propose the minimal fix that addresses the root cause
+- Explain why this fix is correct (not just that it works)
+- Suggest a regression test that would catch this bug
+- Note any related code that might have the same issue
+
+## Quality checks
+
+- [ ] Root cause identified with specific evidence (file, line, data flow)
+- [ ] Fix addresses root cause, not just symptoms
+- [ ] Causal chain explains all observed symptoms
+- [ ] Regression test proposed
+- [ ] No speculative fixes applied without evidence
+
+## Guardrail notes
+
+Low risk during investigation (read-only). The fix itself may require approval depending on scope. Always present the root cause analysis before applying any fix.
+`,
+    bundled_files: [
+        {
+            path: 'references/REFERENCE.md',
+            description: 'Common bug patterns, investigation commands, and root cause analysis templates',
+            load_when: 'Investigating unfamiliar bug categories or need investigation command references',
+            content: `# Debugging Reference
+
+## Common Bug Patterns
+
+### State-Related
+- **Stale state**: Component reads cached/outdated value after mutation
+- **Race condition**: Two operations assume exclusive access to shared state
+- **Missing initialization**: Variable used before assignment, default value wrong
+- **State leak**: State from one request/session bleeds into another
+
+### Type-Related
+- **Null/undefined access**: Property access on null without guard
+- **Type coercion**: Implicit conversion produces unexpected value (e.g., "5" + 3 = "53")
+- **Schema mismatch**: API response shape differs from expected type
+
+### Async-Related
+- **Unhandled rejection**: Promise error not caught
+- **Ordering assumption**: Code assumes async operations complete in call order
+- **Timeout**: Operation takes longer than expected, no timeout configured
+- **Resource leak**: Connection/handle opened but never closed on error path
+
+### Integration-Related
+- **API contract change**: Upstream service changed response format
+- **Environment difference**: Works locally, fails in CI/production
+- **Dependency version**: Transitive dependency upgrade changed behavior
+
+## Investigation Commands
+
+\`\`\`bash
+# Find what changed recently near the failure
+git log --oneline -10 -- <file>
+git blame -L <start>,<end> <file>
+
+# Search for similar patterns in codebase
+grep -rn "<error_pattern>" src/
+grep -rn "<function_name>" src/ --include="*.test.*"
+
+# Check for the same bug elsewhere
+grep -rn "<buggy_pattern>" src/ | grep -v test | grep -v node_modules
+\`\`\`
+
+## Root Cause Report Template
+
+\`\`\`
+SYMPTOM: [What the user sees]
+ROOT CAUSE: [Why it happens — exact file:line and mechanism]
+EVIDENCE: [What proves this is the cause, not just a correlate]
+FIX: [Minimal change that addresses the root cause]
+REGRESSION TEST: [Test that catches this bug if it recurs]
+RELATED: [Other code with the same pattern that might also be affected]
+\`\`\`
+`,
+        },
+    ],
+};
+//# sourceMappingURL=debugging-issues.js.map

package/dist/domains/development-agent/skills/debugging-issues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugging-issues.js","sourceRoot":"","sources":["../../../../domains/development-agent/skills/debugging-issues.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,QAAQ,EAAE,kBAAkB;IAC5B,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE,uPAAuP;IACpQ,IAAI,EAAE,CAAC,aAAa,EAAE,WAAW,EAAE,eAAe,CAAC;IACnD,UAAU,EAAE,KAAc;IAC1B,cAAc,EAAE,CAAC,aAAa,CAAC;IAC/B,mBAAmB,EAAE,CAAC,aAAa,EAAE,UAAU,EAAE,OAAO,CAAC;IACzD,UAAU,EAAE,CAAC,eAAe,CAAC;IAC7B,cAAc,EAAE,SAAS;IACzB,aAAa,EAAE,SAAkB;IAEjC,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EnB;IAEC,aAAa,EAAE;QACb;YACE,IAAI,EAAE,yBAAyB;YAC/B,WAAW,EAAE,gFAAgF;YAC7F,SAAS,EAAE,kFAAkF;YAC7F,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDd;SACI;KACF;CACF,CAAC"}

package/dist/domains/development-agent/skills/documenting-code.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Documenting Code Skill
+ *
+ * Generate documentation following user's documentation philosophy.
+ */
+export declare const DocumentingCodeSkill: {
+    skill_id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    risk_level: "low";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    prerequisites: string[];
+    pipeline_phase: string;
+    context_model: "inherit";
+    skill_md_content: string;
+};
+//# sourceMappingURL=documenting-code.d.ts.map

package/dist/domains/development-agent/skills/documenting-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documenting-code.d.ts","sourceRoot":"","sources":["../../../../domains/development-agent/skills/documenting-code.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;CAsFhC,CAAC"}

package/dist/domains/development-agent/skills/documenting-code.js

@@ -0,0 +1,92 @@
+/**
+ * Documenting Code Skill
+ *
+ * Generate documentation following user's documentation philosophy.
+ */
+export const DocumentingCodeSkill = {
+    skill_id: 'documenting-code',
+    name: 'Documenting Code',
+    description: 'Generates documentation following the user\'s documentation philosophy and writing conventions. Use when writing READMEs, API docs, architecture docs, inline documentation, or when the user asks to document, explain, or write docs for code.',
+    tags: ['development', 'documentation', 'writing'],
+    risk_level: 'low',
+    required_tools: ['file-system'],
+    compatible_runtimes: ['claude-code', 'openclaw', 'manus'],
+    prerequisites: ['code-review'],
+    pipeline_phase: 'connect',
+    context_model: 'inherit',
+    skill_md_content: `# Documenting Code
+
+## Purpose
+
+Generates documentation that follows the user's documentation philosophy: what to document, how much detail, and what style. Comments explain "why", not "what".
+
+## When to use
+
+- Writing or updating README files
+- Documenting public APIs or modules
+- Adding architecture decision records
+- When the user asks to "document this", "add docs", or "explain this code"
+
+## When NOT to use
+
+- For inline comments on obvious code (code should be self-documenting)
+- For generating JSDoc/TSDoc on every function (only public API)
+- When the user wants code reviewed, not documented (use code-review)
+
+## Inputs
+
+- **target**: File paths, module, or codebase area to document
+- **type**: Documentation type (README, API, architecture, inline, changelog)
+- **audience**: Who reads this (new contributors, API consumers, future maintainers)
+
+## Outputs
+
+- **documentation**: Markdown files or inline comments following user conventions
+- **structure**: Where docs should live in the project
+
+## Procedure
+
+### Step 1: Understand the code
+
+- Read the target code thoroughly
+- Identify the public API and key abstractions
+- Note non-obvious design decisions and tradeoffs
+
+### Step 2: Match user's documentation style
+
+Apply the user's documentation philosophy:
+- Comments explain "why", never "what"
+- Self-documenting code through good naming reduces comment need
+- READMEs should have a quick-start that works in under 5 minutes
+- API docs should show usage examples, not just signatures
+
+### Step 3: Write documentation
+
+For each documentation type:
+
+**README**: Quick start first, then architecture, then contributing guide.
+**API docs**: One example per endpoint/function. Show the happy path, then edge cases.
+**Architecture**: Explain the "why" behind structural decisions. Include diagrams if helpful.
+**Inline**: Only where the code's intent isn't obvious from reading it.
+
+### Step 4: Verify accuracy
+
+- Run any code examples to confirm they work
+- Check that documented APIs match actual signatures
+- Verify file paths and commands are correct
+
+## Quality checks
+
+- [ ] Quick-start section works end-to-end (if README)
+- [ ] Code examples are runnable and correct
+- [ ] Comments explain "why", not "what"
+- [ ] No documentation for self-evident code
+- [ ] Consistent terminology throughout
+- [ ] File paths and commands verified
+
+## Guardrail notes
+
+Low risk. Documentation is additive. No approval needed unless modifying existing docs that others maintain.
+`,
+};
+//# sourceMappingURL=documenting-code.js.map

package/dist/domains/development-agent/skills/documenting-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documenting-code.js","sourceRoot":"","sources":["../../../../domains/development-agent/skills/documenting-code.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,QAAQ,EAAE,kBAAkB;IAC5B,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE,kPAAkP;IAC/P,IAAI,EAAE,CAAC,aAAa,EAAE,eAAe,EAAE,SAAS,CAAC;IACjD,UAAU,EAAE,KAAc;IAC1B,cAAc,EAAE,CAAC,aAAa,CAAC;IAC/B,mBAAmB,EAAE,CAAC,aAAa,EAAE,UAAU,EAAE,OAAO,CAAC;IACzD,aAAa,EAAE,CAAC,aAAa,CAAC;IAC9B,cAAc,EAAE,SAAS;IACzB,aAAa,EAAE,SAAkB;IAEjC,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEnB;CACA,CAAC"}

package/dist/domains/development-agent/skills/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Development Agent Skills Library
+ *
+ * Pre-built skills for software development agents.
+ */
+import { CodeReviewSkill } from './code-review.js';
+import { RefactorPlanSkill } from './refactor-plan.js';
+import { WritingTestsSkill } from './writing-tests.js';
+import { DebuggingIssuesSkill } from './debugging-issues.js';
+import { DocumentingCodeSkill } from './documenting-code.js';
+export declare const DevelopmentAgentSkills: ({
+    skill_id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    risk_level: "low";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    feeds_into: string[];
+    pipeline_phase: string;
+    context_model: "inherit";
+    skill_md_content: string;
+    bundled_files: {
+        path: string;
+        description: string;
+        load_when: string;
+        content: string;
+    }[];
+} | {
+    skill_id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    risk_level: "med";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    prerequisites: string[];
+    pipeline_phase: string;
+    context_model: "inherit";
+    skill_md_content: string;
+} | {
+    skill_id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    risk_level: "low";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    prerequisites: string[];
+    pipeline_phase: string;
+    context_model: "inherit";
+    skill_md_content: string;
+})[];
+export { CodeReviewSkill, RefactorPlanSkill, WritingTestsSkill, DebuggingIssuesSkill, DocumentingCodeSkill, };
+//# sourceMappingURL=index.d.ts.map

package/dist/domains/development-agent/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domains/development-agent/skills/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMlC,CAAC;AAEF,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,GACrB,CAAC"}

package/dist/domains/development-agent/skills/index.js

@@ -0,0 +1,19 @@
+/**
+ * Development Agent Skills Library
+ *
+ * Pre-built skills for software development agents.
+ */
+import { CodeReviewSkill } from './code-review.js';
+import { RefactorPlanSkill } from './refactor-plan.js';
+import { WritingTestsSkill } from './writing-tests.js';
+import { DebuggingIssuesSkill } from './debugging-issues.js';
+import { DocumentingCodeSkill } from './documenting-code.js';
+export const DevelopmentAgentSkills = [
+    CodeReviewSkill,
+    RefactorPlanSkill,
+    WritingTestsSkill,
+    DebuggingIssuesSkill,
+    DocumentingCodeSkill,
+];
+export { CodeReviewSkill, RefactorPlanSkill, WritingTestsSkill, DebuggingIssuesSkill, DocumentingCodeSkill, };
+//# sourceMappingURL=index.js.map

package/dist/domains/development-agent/skills/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domains/development-agent/skills/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,eAAe;IACf,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,oBAAoB;CACrB,CAAC;AAEF,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,GACrB,CAAC"}

package/dist/domains/development-agent/skills/refactor-plan.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Refactor Plan Skill
+ *
+ * Propose refactoring following user's engineering standards.
+ */
+export declare const RefactorPlanSkill: {
+    skill_id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    risk_level: "med";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    prerequisites: string[];
+    pipeline_phase: string;
+    context_model: "inherit";
+    skill_md_content: string;
+};
+//# sourceMappingURL=refactor-plan.d.ts.map

package/dist/domains/development-agent/skills/refactor-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactor-plan.d.ts","sourceRoot":"","sources":["../../../../domains/development-agent/skills/refactor-plan.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;CA+G7B,CAAC"}

package/dist/domains/development-agent/skills/refactor-plan.js

@@ -0,0 +1,117 @@
+/**
+ * Refactor Plan Skill
+ *
+ * Propose refactoring following user's engineering standards.
+ */
+export const RefactorPlanSkill = {
+    skill_id: 'refactor-plan',
+    name: 'Refactor Plan',
+    description: 'Analyzes code and proposes structured refactoring plans following engineering principles. Use when code has technical debt, architecture needs to evolve, or the user asks to refactor, restructure, or clean up code.',
+    tags: ['development', 'refactoring', 'architecture'],
+    risk_level: 'med',
+    required_tools: ['file-system'],
+    compatible_runtimes: ['claude-code', 'openclaw', 'manus'],
+    prerequisites: ['code-review'],
+    pipeline_phase: 'process',
+    context_model: 'inherit',
+    skill_md_content: `# Refactor Plan
+
+## Purpose
+
+Analyze existing code and propose a structured refactoring plan that improves code quality while aligning with the user's engineering principles and standards.
+
+## When to use
+
+- Code has accumulated technical debt
+- Architecture needs to evolve for new requirements
+- Readability or maintainability needs improvement
+- Preparing for a major feature that requires cleaner foundations
+
+## When NOT to use
+
+- For cosmetic-only changes (formatting, naming) — use linter
+- When the user wants a code review without changes — use code-review
+- For greenfield development (no existing code to refactor)
+
+## Inputs
+
+- **target**: File paths or module to refactor
+- **goal**: What the refactoring should achieve (readability, performance, extensibility, etc.)
+- **constraints**: Things that must not change (public API, behavior, etc.)
+- **budget**: Scope limit (small: single file, medium: module, large: cross-cutting)
+
+## Outputs
+
+- **plan**: Structured refactoring plan with:
+  - **assessment**: Current state analysis and identified problems
+  - **steps**: Ordered list of refactoring steps, each with:
+    - description of the change
+    - files affected
+    - risk level
+    - estimated scope
+  - **principle_alignment**: How the refactoring serves user's engineering principles
+  - **risks**: What could go wrong and mitigation strategies
+  - **testing_strategy**: How to verify the refactoring didn't break anything
+
+## Procedure
+
+### Step 1: Analyze current state
+
+- Read the target code thoroughly
+- Map dependencies (what depends on this code, what it depends on)
+- Identify code smells and structural issues
+- Note what works well (don't refactor unnecessarily)
+
+### Step 2: Align with principles
+
+- Review user's engineering principles
+- Determine which principles the refactoring should serve
+- Ensure the proposed changes don't violate other principles
+
+### Step 3: Design the refactoring
+
+- Break into small, independently testable steps
+- Order steps to minimize risk (safest changes first)
+- Identify which steps require approval (behavior changes, API changes)
+- Ensure each step leaves the code in a working state
+
+### Step 4: Assess risks
+
+- What tests exist? What's the coverage?
+- What downstream dependencies could break?
+- Is there a rollback strategy?
+
+### Step 5: Present the plan
+
+Structure the plan so the user can approve step-by-step. Each step should be independently executable.
+
+## Quality checks
+
+- [ ] Current state thoroughly analyzed
+- [ ] All affected files identified
+- [ ] Steps are ordered by risk (safest first)
+- [ ] Each step leaves code in a working state
+- [ ] Testing strategy covers refactored code
+- [ ] Plan aligns with user's engineering principles
+- [ ] Risks identified with mitigation strategies
+
+## Guardrail notes
+
+Medium risk — the plan itself is read-only, but executing it modifies code. The plan should be reviewed before execution. Each step with risk_level >= medium requires approval.
+
+## Progressive Disclosure
+
+### Minimal Context (Always Load)
+- Purpose: Propose refactoring plans aligned with engineering principles
+- When to use: Technical debt, architecture evolution, maintainability improvement
+
+### On Invoke (Load When Skill is Invoked)
+- Full analysis and planning procedure
+- Risk assessment and testing strategy requirements
+
+### On Demand Resources
+- Refactoring pattern catalog
+- Risk mitigation strategies
+`
+};
+//# sourceMappingURL=refactor-plan.js.map

package/dist/domains/development-agent/skills/refactor-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactor-plan.js","sourceRoot":"","sources":["../../../../domains/development-agent/skills/refactor-plan.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,eAAe;IACzB,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,wNAAwN;IACrO,IAAI,EAAE,CAAC,aAAa,EAAE,aAAa,EAAE,cAAc,CAAC;IACpD,UAAU,EAAE,KAAc;IAC1B,cAAc,EAAE,CAAC,aAAa,CAAC;IAC/B,mBAAmB,EAAE,CAAC,aAAa,EAAE,UAAU,EAAE,OAAO,CAAC;IACzD,aAAa,EAAE,CAAC,aAAa,CAAC;IAC9B,cAAc,EAAE,SAAS;IACzB,aAAa,EAAE,SAAkB;IAEjC,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGnB;CACA,CAAC"}

package/dist/domains/development-agent/skills/writing-tests.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Writing Tests Skill
+ *
+ * Generate tests following user's testing philosophy and quality bar.
+ */
+export declare const WritingTestsSkill: {
+    skill_id: string;
+    name: string;
+    description: string;
+    tags: string[];
+    risk_level: "low";
+    required_tools: string[];
+    compatible_runtimes: string[];
+    prerequisites: string[];
+    feeds_into: string[];
+    pipeline_phase: string;
+    context_model: "inherit";
+    skill_md_content: string;
+};
+//# sourceMappingURL=writing-tests.d.ts.map

package/dist/domains/development-agent/skills/writing-tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writing-tests.d.ts","sourceRoot":"","sources":["../../../../domains/development-agent/skills/writing-tests.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAuF7B,CAAC"}

package/dist/domains/development-agent/skills/writing-tests.js

@@ -0,0 +1,93 @@
+/**
+ * Writing Tests Skill
+ *
+ * Generate tests following user's testing philosophy and quality bar.
+ */
+export const WritingTestsSkill = {
+    skill_id: 'writing-tests',
+    name: 'Writing Tests',
+    description: 'Generates tests following the user\'s testing philosophy, coverage expectations, and quality bar. Use when writing tests for new features, adding regression tests for bugs, improving test coverage, or when the user asks to test, add tests, or verify code.',
+    tags: ['development', 'testing', 'quality'],
+    risk_level: 'low',
+    required_tools: ['file-system'],
+    compatible_runtimes: ['claude-code', 'openclaw', 'manus'],
+    prerequisites: ['code-review'],
+    feeds_into: ['refactor-plan'],
+    pipeline_phase: 'verify',
+    context_model: 'inherit',
+    skill_md_content: `# Writing Tests
+
+## Purpose
+
+Generates tests that follow the user's testing philosophy, preferred frameworks, naming conventions, and coverage expectations.
+
+## When to use
+
+- Writing tests for new features or modules
+- Adding regression tests for bug fixes (TDD: write failing test first)
+- Improving test coverage on critical paths
+- When the user asks to "test this", "add tests", or "verify"
+
+## When NOT to use
+
+- For manual QA or exploratory testing (out of scope)
+- When tests already exist and just need running (use the test runner directly)
+- For performance benchmarking (use profiling tools)
+
+## Inputs
+
+- **target**: File paths or module to test
+- **focus**: What aspect to test (behavior, edge cases, integration, regression)
+- **framework**: Test framework if known (vitest, jest, mocha, pytest, go test, etc.)
+
+## Outputs
+
+- **test_files**: One or more test files following project conventions
+- **coverage_summary**: Which critical paths are now covered
+
+## Procedure
+
+### Step 1: Understand what to test
+
+- Read the target code and its public API
+- Identify the behavior contract (what it promises to do)
+- Note edge cases, error paths, and boundary conditions
+- Check existing tests for patterns and conventions
+
+### Step 2: Choose test strategy
+
+Based on user's testing philosophy:
+- **Unit tests**: For pure functions and isolated logic
+- **Integration tests**: For cross-module interactions and real dependencies
+- **Regression tests**: For specific bugs (write the failing case first)
+
+Prefer testing behavior over implementation details. A test that breaks when you refactor internals is worse than no test.
+
+### Step 3: Write tests
+
+- Follow project naming conventions for test files and test names
+- Use descriptive test names that explain the expected behavior
+- Structure: Arrange (setup) -> Act (execute) -> Assert (verify)
+- One logical assertion per test (multiple expect calls are fine if testing one behavior)
+
+### Step 4: Verify tests
+
+- Run the test suite to confirm tests pass
+- Intentionally break the target code to verify tests catch it
+- Check that test names read as documentation
+
+## Quality checks
+
+- [ ] Tests cover the critical path (happy path)
+- [ ] At least one edge case or error path tested
+- [ ] Test names describe expected behavior, not implementation
+- [ ] Tests follow project conventions (naming, file location, framework)
+- [ ] Tests are independent (no shared mutable state between tests)
+- [ ] No implementation details tested (tests survive refactoring)
+
+## Guardrail notes
+
+Low risk. Tests are additive and don't modify production code. No approval needed.
+`,
+};
+//# sourceMappingURL=writing-tests.js.map

package/dist/domains/development-agent/skills/writing-tests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writing-tests.js","sourceRoot":"","sources":["../../../../domains/development-agent/skills/writing-tests.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,eAAe;IACzB,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,iQAAiQ;IAC9Q,IAAI,EAAE,CAAC,aAAa,EAAE,SAAS,EAAE,SAAS,CAAC;IAC3C,UAAU,EAAE,KAAc;IAC1B,cAAc,EAAE,CAAC,aAAa,CAAC;IAC/B,mBAAmB,EAAE,CAAC,aAAa,EAAE,UAAU,EAAE,OAAO,CAAC;IACzD,aAAa,EAAE,CAAC,aAAa,CAAC;IAC9B,UAAU,EAAE,CAAC,eAAe,CAAC;IAC7B,cAAc,EAAE,QAAQ;IACxB,aAAa,EAAE,SAAkB;IAEjC,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEnB;CACA,CAAC"}

package/dist/domains/general-agent/domain.d.ts

@@ -0,0 +1,9 @@
+/**
+ * General Agent Domain
+ *
+ * Broad domain for operators who want one adaptable assistant that can
+ * plan, research, execute, and report across mixed workflows.
+ */
+import { DomainDefinition } from '../types.js';
+export declare const GeneralAgentDomain: DomainDefinition;
+//# sourceMappingURL=domain.d.ts.map

package/dist/domains/general-agent/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../domains/general-agent/domain.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,eAAO,MAAM,kBAAkB,EAAE,gBA4BhC,CAAC"}