@actrun_ai/tastekit-core 0.1.0

package/dist/schemas/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../schemas/workspace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;GAIG;AAEH,eAAO,MAAM,qBAAqB;;;;IAKhC,mEAAmE;;IAGnE,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAchD,8EAA8E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9E,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB,uDAAuD;;IAEvD,iCAAiC;;IAEjC,sCAAsC;;IAEtC,uEAAuE;;;;;;;;;;;;EAEvE,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;IAIlC,0DAA0D;;IAE1D,wDAAwD;;IAExD,2EAA2E;;QAxB3E,uDAAuD;;QAEvD,iCAAiC;;QAEjC,sCAAsC;;QAEtC,uEAAuE;;;;;;;;;;;;;IAoBvE,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjE,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;QAzB/B,0DAA0D;;QAE1D,wDAAwD;;QAExD,2EAA2E;;YAxB3E,uDAAuD;;YAEvD,iCAAiC;;YAEjC,sCAAsC;;YAEtC,uEAAuE;;;;;;;;;;;;;QAoBvE,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BjE,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;IAe7B,kCAAkC;;IAGlC,sCAAsC;;;;;;;;;;;IAMtC,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;YAhExC,0DAA0D;;YAE1D,wDAAwD;;YAExD,2EAA2E;;gBAxB3E,uDAAuD;;gBAEvD,iCAAiC;;gBAEjC,sCAAsC;;gBAEtC,uEAAuE;;;;;;;;;;;;;YAoBvE,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6DjE,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9D,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/schemas/workspace.js

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import { LLMProviderConfigSchema } from '../llm/provider.js';
+/**
+ * Workspace Configuration Schema
+ *
+ * Configuration for a TasteKit workspace (.tastekit/tastekit.yaml)
+ */
+export const WorkspaceConfigSchema = z.object({
+    version: z.string().describe('TasteKit version'),
+    project_name: z.string(),
+    created_at: z.string().datetime(),
+    /** Selected domain (e.g., 'general-agent', 'development-agent') */
+    domain_id: z.string().optional(),
+    /** LLM provider configuration for onboarding */
+    llm_provider: LLMProviderConfigSchema.optional(),
+    onboarding: z.object({
+        depth: z.enum(['quick', 'guided', 'operator']),
+        completed: z.boolean().default(false),
+        session_path: z.string().optional().describe('Path to canonical session.json'),
+    }).optional(),
+    compilation: z.object({
+        last_compiled_at: z.string().datetime().optional(),
+        artifacts_version: z.string().optional(),
+    }).optional(),
+    /** Voice configuration — validated by @actrun_ai/tastekit-voice at runtime */
+    voice: z.any().optional(),
+});
+/**
+ * Interview transcript turn
+ */
+export const InterviewTurnSchema = z.object({
+    turn_number: z.number(),
+    role: z.enum(['interviewer', 'user']),
+    content: z.string(),
+    timestamp: z.string(),
+    dimension_refs: z.array(z.string()).optional(),
+});
+/**
+ * Confidence signal — a single piece of evidence from a conversation turn.
+ * Accumulates toward the dimension's confidence threshold (default 1.5).
+ */
+export const SignalSchema = z.object({
+    /** Weight: HIGH=1.0, MED=0.6, LOW=0.3, INFERRED=0.2 */
+    weight: z.number(),
+    /** How the signal was derived */
+    source: z.enum(['explicit', 'implicit', 'inferred', 'anti']),
+    /** Which turn produced this signal */
+    turn_number: z.number(),
+    /** Optional excerpt from the conversation that produced this signal */
+    excerpt: z.string().optional(),
+});
+/**
+ * Dimension coverage tracking — with confidence-weighted signal extraction.
+ *
+ * Backward compatible: old sessions without confidence/signals still work
+ * because all new fields have defaults.
+ */
+export const DimensionCoverageSchema = z.object({
+    dimension_id: z.string(),
+    status: z.enum(['not_started', 'in_progress', 'covered', 'skipped']),
+    /** Cumulative confidence score (sum of signal weights) */
+    confidence: z.number().min(0).default(0),
+    /** Confidence threshold for resolution (default 1.5) */
+    confidence_threshold: z.number().default(1.5),
+    /** Signal history — each observation that contributed to this dimension */
+    signals: z.array(SignalSchema).default([]),
+    /** Explicit negatives — things the user said they do NOT want */
+    anti_signals: z.array(z.string()).default([]),
+    summary: z.string().optional(),
+    extracted_facts: z.array(z.string()).optional(),
+    relevant_turns: z.array(z.number()),
+});
+export const InterviewMetaSchema = z.object({
+    pacing_position: z.enum(['early', 'mid', 'late']).optional(),
+    fatigue_detected: z.boolean().optional(),
+    framework_active: z.string().optional(),
+    draft_triggered: z.boolean().default(false),
+    confirmation_count: z.number().default(0),
+});
+/**
+ * Interview state (for resume support)
+ */
+export const InterviewStateSchema = z.object({
+    transcript: z.array(InterviewTurnSchema),
+    dimension_coverage: z.array(DimensionCoverageSchema),
+    is_complete: z.boolean(),
+    turn_count: z.number(),
+    interview_meta: InterviewMetaSchema.optional(),
+    structured_answers: z.any().optional(),
+});
+/**
+ * Session State Schema
+ *
+ * Resumable onboarding state (canonical: .tastekit/session.json)
+ * All new fields are optional for backward compatibility with old sessions.
+ */
+export const SessionStateSchema = z.object({
+    session_id: z.string(),
+    started_at: z.string().datetime(),
+    last_updated_at: z.string().datetime(),
+    depth: z.enum(['quick', 'guided', 'operator']),
+    current_step: z.string(),
+    completed_steps: z.array(z.string()),
+    answers: z.record(z.any()).describe('User answers by question ID'),
+    metadata: z.record(z.any()).optional(),
+    // --- LLM interview extensions (all optional for backward compat) ---
+    /** Domain selected during init */
+    domain_id: z.string().optional(),
+    /** LLM provider used for interview */
+    llm_provider: z.object({
+        name: z.string(),
+        model: z.string().optional(),
+    }).optional(),
+    /** Full interview state (for resume) */
+    interview: InterviewStateSchema.optional(),
+    /** Structured answers extracted by LLM at end of interview */
+    structured_answers: z.any().optional(),
+});
+//# sourceMappingURL=workspace.js.map

package/dist/schemas/workspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../schemas/workspace.ts"],"names":[],"mappings":"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"}

package/dist/skills/constraints.d.ts

@@ -0,0 +1,19 @@
+import { ConstraintResult } from '../schemas/skills.js';
+/** Skills must not exceed a maximum size. */
+export declare function validateSize(content: string, maxBytes?: number): ConstraintResult;
+/** Evolved version can't be more than N% larger than the original. */
+export declare function validateGrowth(original: string, evolved: string, maxGrowthPercent?: number): ConstraintResult;
+/** Skill content must not be empty. */
+export declare function validateNonEmpty(content: string): ConstraintResult;
+/**
+ * Skill must have required SKILL.md sections.
+ *
+ * Required: Purpose, Procedure (or Steps), and Inputs (or Outputs).
+ */
+export declare function validateStructure(content: string): ConstraintResult;
+/** Run all constraints. Returns array of results (all must pass for acceptance). */
+export declare function validateAll(content: string, baseline?: string, opts?: {
+    maxBytes?: number;
+    maxGrowthPct?: number;
+}): ConstraintResult[];
+//# sourceMappingURL=constraints.d.ts.map

package/dist/skills/constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../skills/constraints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAYxD,6CAA6C;AAC7C,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAoB,GAAG,gBAAgB,CAU5F;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,gBAAgB,SAAyB,GACxC,gBAAgB,CAuBlB;AAED,uCAAuC;AACvC,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAOlE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAwBnE;AAED,oFAAoF;AACpF,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAClD,gBAAgB,EAAE,CAYpB"}

package/dist/skills/constraints.js

@@ -0,0 +1,91 @@
+/**
+ * Skill Constraint Validation
+ *
+ * Safety gates that every evolved skill must pass before acceptance.
+ * Adapted from NousResearch/hermes-agent-self-evolution constraint system.
+ */
+const DEFAULT_MAX_BYTES = 15360; // 15KB
+const DEFAULT_MAX_GROWTH_PCT = 20;
+/** Skills must not exceed a maximum size. */
+export function validateSize(content, maxBytes = DEFAULT_MAX_BYTES) {
+    const size = Buffer.byteLength(content, 'utf-8');
+    return {
+        passed: size <= maxBytes,
+        constraint_id: 'size_limit',
+        message: size <= maxBytes
+            ? `Size OK (${size} bytes)`
+            : `Skill exceeds max size: ${size} > ${maxBytes} bytes`,
+        details: { size, maxBytes },
+    };
+}
+/** Evolved version can't be more than N% larger than the original. */
+export function validateGrowth(original, evolved, maxGrowthPercent = DEFAULT_MAX_GROWTH_PCT) {
+    const originalSize = Buffer.byteLength(original, 'utf-8');
+    const evolvedSize = Buffer.byteLength(evolved, 'utf-8');
+    if (originalSize === 0) {
+        return {
+            passed: true,
+            constraint_id: 'growth_limit',
+            message: 'Original was empty — growth check skipped',
+        };
+    }
+    const growthPct = ((evolvedSize - originalSize) / originalSize) * 100;
+    const passed = growthPct <= maxGrowthPercent;
+    return {
+        passed,
+        constraint_id: 'growth_limit',
+        message: passed
+            ? `Growth OK (${growthPct.toFixed(1)}%)`
+            : `Skill grew too much: ${growthPct.toFixed(1)}% > ${maxGrowthPercent}% allowed`,
+        details: { originalSize, evolvedSize, growthPct: Math.round(growthPct * 10) / 10, maxGrowthPercent },
+    };
+}
+/** Skill content must not be empty. */
+export function validateNonEmpty(content) {
+    const stripped = content.trim();
+    return {
+        passed: stripped.length > 0,
+        constraint_id: 'non_empty',
+        message: stripped.length > 0 ? 'Content is non-empty' : 'Skill content is empty',
+    };
+}
+/**
+ * Skill must have required SKILL.md sections.
+ *
+ * Required: Purpose, Procedure (or Steps), and Inputs (or Outputs).
+ */
+export function validateStructure(content) {
+    const lower = content.toLowerCase();
+    const requiredPatterns = [
+        { name: 'Purpose', patterns: ['## purpose', '# purpose', 'purpose:'] },
+        { name: 'Procedure', patterns: ['## procedure', '# procedure', '## steps', '# steps', 'procedure:'] },
+        { name: 'Inputs/Outputs', patterns: ['## inputs', '# inputs', '## outputs', '# outputs', 'inputs:', 'outputs:'] },
+    ];
+    const missing = [];
+    for (const req of requiredPatterns) {
+        const found = req.patterns.some(p => lower.includes(p));
+        if (!found)
+            missing.push(req.name);
+    }
+    return {
+        passed: missing.length === 0,
+        constraint_id: 'structure',
+        message: missing.length === 0
+            ? 'All required sections present'
+            : `Missing required sections: ${missing.join(', ')}`,
+        details: { missing },
+    };
+}
+/** Run all constraints. Returns array of results (all must pass for acceptance). */
+export function validateAll(content, baseline, opts) {
+    const results = [
+        validateNonEmpty(content),
+        validateSize(content, opts?.maxBytes),
+        validateStructure(content),
+    ];
+    if (baseline) {
+        results.push(validateGrowth(baseline, content, opts?.maxGrowthPct));
+    }
+    return results;
+}
+//# sourceMappingURL=constraints.js.map

package/dist/skills/constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.js","sourceRoot":"","sources":["../../skills/constraints.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,MAAM,iBAAiB,GAAG,KAAK,CAAC,CAAC,OAAO;AACxC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAElC,6CAA6C;AAC7C,MAAM,UAAU,YAAY,CAAC,OAAe,EAAE,QAAQ,GAAG,iBAAiB;IACxE,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjD,OAAO;QACL,MAAM,EAAE,IAAI,IAAI,QAAQ;QACxB,aAAa,EAAE,YAAY;QAC3B,OAAO,EAAE,IAAI,IAAI,QAAQ;YACvB,CAAC,CAAC,YAAY,IAAI,SAAS;YAC3B,CAAC,CAAC,2BAA2B,IAAI,MAAM,QAAQ,QAAQ;QACzD,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;KAC5B,CAAC;AACJ,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,cAAc,CAC5B,QAAgB,EAChB,OAAe,EACf,gBAAgB,GAAG,sBAAsB;IAEzC,MAAM,YAAY,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC1D,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAExD,IAAI,YAAY,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,MAAM,EAAE,IAAI;YACZ,aAAa,EAAE,cAAc;YAC7B,OAAO,EAAE,2CAA2C;SACrD,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GAAG,CAAC,CAAC,WAAW,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,GAAG,CAAC;IACtE,MAAM,MAAM,GAAG,SAAS,IAAI,gBAAgB,CAAC;IAE7C,OAAO;QACL,MAAM;QACN,aAAa,EAAE,cAAc;QAC7B,OAAO,EAAE,MAAM;YACb,CAAC,CAAC,cAAc,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI;YACxC,CAAC,CAAC,wBAAwB,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,gBAAgB,WAAW;QAClF,OAAO,EAAE,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,gBAAgB,EAAE;KACrG,CAAC;AACJ,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,gBAAgB,CAAC,OAAe;IAC9C,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAChC,OAAO;QACL,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC;QAC3B,aAAa,EAAE,WAAW;QAC1B,OAAO,EAAE,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,wBAAwB;KACjF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAe;IAC/C,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAEpC,MAAM,gBAAgB,GAAgD;QACpE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE;QACtE,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,CAAC,EAAE;QACrG,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE;KAClH,CAAC;IAEF,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK;YAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAED,OAAO;QACL,MAAM,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;QAC5B,aAAa,EAAE,WAAW;QAC1B,OAAO,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;YAC3B,CAAC,CAAC,+BAA+B;YACjC,CAAC,CAAC,8BAA8B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QACtD,OAAO,EAAE,EAAE,OAAO,EAAE;KACrB,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,WAAW,CACzB,OAAe,EACf,QAAiB,EACjB,IAAmD;IAEnD,MAAM,OAAO,GAAuB;QAClC,gBAAgB,CAAC,OAAO,CAAC;QACzB,YAAY,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC;QACrC,iBAAiB,CAAC,OAAO,CAAC;KAC3B,CAAC;IAEF,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/skills/generator.d.ts

@@ -0,0 +1,13 @@
+import { SkillsManifestV1 } from '../schemas/skills.js';
+import { ConstitutionV1 } from '../schemas/constitution.js';
+/**
+ * Skills generator
+ *
+ * Generates Skills library from constitution and user profile.
+ */
+export interface SkillGenerationOptions {
+    workspacePath: string;
+    constitution: ConstitutionV1;
+}
+export declare function generateSkills(options: SkillGenerationOptions): SkillsManifestV1;
+//# sourceMappingURL=generator.d.ts.map

package/dist/skills/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../skills/generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAiB,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D;;;;GAIG;AAEH,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,cAAc,CAAC;CAC9B;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,sBAAsB,GAAG,gBAAgB,CAuChF"}

package/dist/skills/generator.js

@@ -0,0 +1,126 @@
+import { join } from 'path';
+import { writeFileSafe } from '../utils/filesystem.js';
+import { stringifyYAML } from '../utils/yaml.js';
+export function generateSkills(options) {
+    const { workspacePath, constitution } = options;
+    const skillsPath = join(workspacePath, 'skills');
+    // Generate default skills based on constitution
+    const skills = [];
+    // Example: Content creation skill
+    const contentSkill = {
+        skill_id: 'content_creation',
+        name: 'Content Creation',
+        description: 'Create written content following user taste and principles',
+        tags: ['writing', 'content', 'creative'],
+        risk_level: 'low',
+        required_tools: [],
+        compatible_runtimes: ['claude-code', 'manus', 'openclaw'],
+    };
+    skills.push(contentSkill);
+    // Generate SKILL.md for content creation
+    const contentSkillMd = generateSkillMarkdown(contentSkill, constitution);
+    writeFileSafe(join(skillsPath, 'content_creation', 'SKILL.md'), contentSkillMd);
+    // Generate manifest
+    const manifest = {
+        schema_version: 'skills_manifest.v1',
+        skills,
+    };
+    writeFileSafe(join(skillsPath, 'manifest.v1.yaml'), stringifyYAML(manifest));
+    return manifest;
+}
+/**
+ * Convert a skill_id to a valid Agent Skills name (kebab-case).
+ */
+function toAgentSkillsName(skillId) {
+    return skillId
+        .toLowerCase()
+        .replace(/_/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .slice(0, 64);
+}
+function generateSkillMarkdown(skill, constitution) {
+    const name = toAgentSkillsName(skill.skill_id);
+    const description = skill.description.slice(0, 1024);
+    return `---
+name: ${name}
+description: ${description}
+---
+
+# ${skill.name}
+
+## Purpose
+
+${skill.description}
+
+## When to use
+
+Use this skill when you need to create written content that follows the user's taste profile and principles.
+
+## When not to use
+
+Do not use this skill for:
+- Technical documentation (use technical writing skill instead)
+- Code generation (use code generation skill instead)
+- Data analysis reports (use data analysis skill instead)
+
+## Inputs
+
+- **topic**: The topic or subject to write about
+- **format**: Desired format (article, blog post, email, etc.)
+- **length**: Target length (short, medium, long)
+
+## Outputs
+
+- Written content following user's tone and principles
+- Metadata about the content (word count, reading time, etc.)
+
+## Procedure
+
+### Minimal context (always load)
+
+1. Review user's top principles:
+${constitution.principles.slice(0, 3).map(p => `   - ${p.statement}`).join('\n')}
+
+2. Apply tone preferences:
+   - Voice: ${constitution.tone.voice_keywords.join(', ')}
+   - Avoid: ${constitution.tone.forbidden_phrases.join(', ') || 'none specified'}
+
+### On invoke (load when skill is invoked)
+
+3. Analyze the topic and determine appropriate structure
+4. Draft content following principles and tone
+5. Review for forbidden phrases and principle violations
+6. Refine and polish
+
+### On demand resources (load only if needed)
+
+- **examples.md**: Example content in user's preferred style
+- **templates/**: Content templates for different formats
+
+## Quality checks
+
+- [ ] Content follows top 3 principles
+- [ ] Tone matches voice keywords
+- [ ] No forbidden phrases used
+- [ ] Appropriate length for format
+- [ ] Clear structure and flow
+
+## Guardrail notes
+
+This skill does not require approval for:
+- Draft generation
+- Content refinement
+
+This skill requires approval for:
+- Publishing content externally
+- Sending content via email or messaging
+
+## Progressive disclosure
+
+This skill uses progressive disclosure to minimize context:
+- **Minimal context**: Top principles and tone (always loaded)
+- **On invoke**: Full procedure and quality checks (loaded when skill runs)
+- **On demand**: Examples and templates (loaded only if explicitly needed)
+`;
+}
+//# sourceMappingURL=generator.js.map

package/dist/skills/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../skills/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAejD,MAAM,UAAU,cAAc,CAAC,OAA+B;IAC5D,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;IAChD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAEjD,gDAAgD;IAChD,MAAM,MAAM,GAAoB,EAAE,CAAC;IAEnC,kCAAkC;IAClC,MAAM,YAAY,GAAkB;QAClC,QAAQ,EAAE,kBAAkB;QAC5B,IAAI,EAAE,kBAAkB;QACxB,WAAW,EAAE,4DAA4D;QACzE,IAAI,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC;QACxC,UAAU,EAAE,KAAK;QACjB,cAAc,EAAE,EAAE;QAClB,mBAAmB,EAAE,CAAC,aAAa,EAAE,OAAO,EAAE,UAAU,CAAC;KAC1D,CAAC;IAEF,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAE1B,yCAAyC;IACzC,MAAM,cAAc,GAAG,qBAAqB,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IACzE,aAAa,CACX,IAAI,CAAC,UAAU,EAAE,kBAAkB,EAAE,UAAU,CAAC,EAChD,cAAc,CACf,CAAC;IAEF,oBAAoB;IACpB,MAAM,QAAQ,GAAqB;QACjC,cAAc,EAAE,oBAAoB;QACpC,MAAM;KACP,CAAC;IAEF,aAAa,CACX,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,EACpC,aAAa,CAAC,QAAQ,CAAC,CACxB,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;GAEG;AACH,SAAS,iBAAiB,CAAC,OAAe;IACxC,OAAO,OAAO;SACX,WAAW,EAAE;SACb,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC;SAClB,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;SAC1B,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAClB,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAoB,EAAE,YAA4B;IAC/E,MAAM,IAAI,GAAG,iBAAiB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC/C,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IACrD,OAAO;QACD,IAAI;eACG,WAAW;;;IAGtB,KAAK,CAAC,IAAI;;;;EAIZ,KAAK,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BjB,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;cAGlE,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC;cAC3C,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC/E,CAAC;AACF,CAAC"}

package/dist/skills/graph.d.ts

@@ -0,0 +1,42 @@
+import { SkillsManifestV1 } from '../schemas/skills.js';
+/**
+ * Skill Graph Analyzer
+ *
+ * Analyzes relationships between skills: pipelines, orphans,
+ * cycles, and missing references.
+ */
+export interface SkillGraphAnalysis {
+    /** Total number of skills */
+    node_count: number;
+    /** Total number of relationships (feeds_into + prerequisites) */
+    edge_count: number;
+    /** Graph density: edges / (nodes * (nodes - 1)) */
+    density: number;
+    /** Skills with no relationships */
+    orphans: string[];
+    /** Skills with 3+ connections */
+    hubs: string[];
+    /** Detected linear chains (A → B → C) */
+    pipelines: string[][];
+    /** Circular dependencies (should be empty) */
+    cycles: string[][];
+    /** References to non-existent skills */
+    missing_refs: Array<{
+        skill_id: string;
+        missing_ref: string;
+        relationship: string;
+    }>;
+}
+/**
+ * Analyze the skill graph from a manifest.
+ */
+export declare function analyzeSkillGraph(manifest: SkillsManifestV1): SkillGraphAnalysis;
+/**
+ * Get the pipeline path starting from a given skill.
+ */
+export declare function getPipelinePath(manifest: SkillsManifestV1, startSkill: string): string[];
+/**
+ * Recommend next skills based on a completed skill.
+ */
+export declare function recommendNextSkill(manifest: SkillsManifestV1, completedSkill: string): string[];
+//# sourceMappingURL=graph.d.ts.map

package/dist/skills/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../skills/graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAiB,MAAM,sBAAsB,CAAC;AAEvE;;;;;GAKG;AAEH,MAAM,WAAW,kBAAkB;IACjC,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,iCAAiC;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,yCAAyC;IACzC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,wCAAwC;IACxC,YAAY,EAAE,KAAK,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,kBAAkB,CAgGhF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBxF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB/F"}

package/dist/skills/graph.js

@@ -0,0 +1,217 @@
+/**
+ * Analyze the skill graph from a manifest.
+ */
+export function analyzeSkillGraph(manifest) {
+    const skills = manifest.skills;
+    const skillIds = new Set(skills.map(s => s.skill_id));
+    const nodeCount = skills.length;
+    // Build adjacency lists
+    const outEdges = new Map(); // skill → skills it feeds into
+    const inEdges = new Map(); // skill → skills that feed into it
+    const allConnections = new Map(); // skill → total connection count
+    const missingRefs = [];
+    let edgeCount = 0;
+    for (const skill of skills) {
+        if (!outEdges.has(skill.skill_id))
+            outEdges.set(skill.skill_id, new Set());
+        if (!inEdges.has(skill.skill_id))
+            inEdges.set(skill.skill_id, new Set());
+        if (!allConnections.has(skill.skill_id))
+            allConnections.set(skill.skill_id, 0);
+        // Process feeds_into
+        for (const target of skill.feeds_into ?? []) {
+            if (!skillIds.has(target)) {
+                missingRefs.push({ skill_id: skill.skill_id, missing_ref: target, relationship: 'feeds_into' });
+                continue;
+            }
+            outEdges.get(skill.skill_id).add(target);
+            if (!inEdges.has(target))
+                inEdges.set(target, new Set());
+            inEdges.get(target).add(skill.skill_id);
+            edgeCount++;
+            allConnections.set(skill.skill_id, (allConnections.get(skill.skill_id) ?? 0) + 1);
+            allConnections.set(target, (allConnections.get(target) ?? 0) + 1);
+        }
+        // Process prerequisites
+        for (const prereq of skill.prerequisites ?? []) {
+            if (!skillIds.has(prereq)) {
+                missingRefs.push({ skill_id: skill.skill_id, missing_ref: prereq, relationship: 'prerequisites' });
+                continue;
+            }
+            // prerequisites is the reverse of feeds_into
+            if (!outEdges.has(prereq))
+                outEdges.set(prereq, new Set());
+            outEdges.get(prereq).add(skill.skill_id);
+            inEdges.get(skill.skill_id).add(prereq);
+            edgeCount++;
+            allConnections.set(skill.skill_id, (allConnections.get(skill.skill_id) ?? 0) + 1);
+            allConnections.set(prereq, (allConnections.get(prereq) ?? 0) + 1);
+        }
+        // Process alternatives (bidirectional, but count once)
+        for (const alt of skill.alternatives ?? []) {
+            if (!skillIds.has(alt)) {
+                missingRefs.push({ skill_id: skill.skill_id, missing_ref: alt, relationship: 'alternatives' });
+            }
+        }
+    }
+    // Deduplicate edges (feeds_into and prerequisites may create duplicates)
+    edgeCount = 0;
+    const seenEdges = new Set();
+    for (const [source, targets] of outEdges) {
+        for (const target of targets) {
+            const key = `${source}→${target}`;
+            if (!seenEdges.has(key)) {
+                seenEdges.add(key);
+                edgeCount++;
+            }
+        }
+    }
+    // Calculate density
+    const density = nodeCount > 1 ? edgeCount / (nodeCount * (nodeCount - 1)) : 0;
+    // Find orphans (no connections at all)
+    const orphans = skills
+        .filter(s => (allConnections.get(s.skill_id) ?? 0) === 0)
+        .map(s => s.skill_id);
+    // Find hubs (3+ connections)
+    const hubs = [...allConnections.entries()]
+        .filter(([, count]) => count >= 3)
+        .map(([id]) => id);
+    // Detect pipelines (linear chains)
+    const pipelines = detectPipelines(skills, outEdges, inEdges);
+    // Detect cycles
+    const cycles = detectCycles(skills, outEdges);
+    return {
+        node_count: nodeCount,
+        edge_count: edgeCount,
+        density,
+        orphans,
+        hubs,
+        pipelines,
+        cycles,
+        missing_refs: missingRefs,
+    };
+}
+/**
+ * Get the pipeline path starting from a given skill.
+ */
+export function getPipelinePath(manifest, startSkill) {
+    const skillMap = new Map(manifest.skills.map(s => [s.skill_id, s]));
+    const path = [startSkill];
+    const visited = new Set([startSkill]);
+    let current = startSkill;
+    while (true) {
+        const skill = skillMap.get(current);
+        if (!skill?.feeds_into?.length)
+            break;
+        const next = skill.feeds_into[0]; // Follow first feed
+        if (visited.has(next))
+            break; // Cycle
+        if (!skillMap.has(next))
+            break; // Missing ref
+        path.push(next);
+        visited.add(next);
+        current = next;
+    }
+    return path;
+}
+/**
+ * Recommend next skills based on a completed skill.
+ */
+export function recommendNextSkill(manifest, completedSkill) {
+    const skill = manifest.skills.find(s => s.skill_id === completedSkill);
+    if (!skill)
+        return [];
+    const nextSkills = [];
+    // Direct feeds_into
+    if (skill.feeds_into) {
+        nextSkills.push(...skill.feeds_into);
+    }
+    // Skills that list this as a prerequisite
+    for (const s of manifest.skills) {
+        if (s.prerequisites?.includes(completedSkill) && !nextSkills.includes(s.skill_id)) {
+            nextSkills.push(s.skill_id);
+        }
+    }
+    return nextSkills;
+}
+/**
+ * Detect linear pipeline chains in the graph.
+ */
+function detectPipelines(skills, outEdges, inEdges) {
+    const pipelines = [];
+    const visited = new Set();
+    // Find chain starts: skills with outgoing edges but no incoming edges
+    for (const skill of skills) {
+        const incoming = inEdges.get(skill.skill_id);
+        const outgoing = outEdges.get(skill.skill_id);
+        if ((!incoming || incoming.size === 0) && outgoing && outgoing.size > 0) {
+            // This is a pipeline start
+            const chain = followChain(skill.skill_id, outEdges, visited);
+            if (chain.length >= 2) {
+                pipelines.push(chain);
+            }
+        }
+    }
+    return pipelines;
+}
+function followChain(start, outEdges, visited) {
+    const chain = [start];
+    visited.add(start);
+    let current = start;
+    while (true) {
+        const targets = outEdges.get(current);
+        if (!targets || targets.size === 0)
+            break;
+        // Follow the first unvisited target
+        let next = null;
+        for (const t of targets) {
+            if (!visited.has(t)) {
+                next = t;
+                break;
+            }
+        }
+        if (!next)
+            break;
+        chain.push(next);
+        visited.add(next);
+        current = next;
+    }
+    return chain;
+}
+/**
+ * Detect cycles using DFS-based cycle detection.
+ */
+function detectCycles(skills, outEdges) {
+    const cycles = [];
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = new Map();
+    const parent = new Map();
+    for (const skill of skills) {
+        color.set(skill.skill_id, WHITE);
+    }
+    function dfs(node, path) {
+        color.set(node, GRAY);
+        path.push(node);
+        for (const neighbor of outEdges.get(node) ?? []) {
+            if (color.get(neighbor) === GRAY) {
+                // Found a cycle — extract it
+                const cycleStart = path.indexOf(neighbor);
+                if (cycleStart >= 0) {
+                    cycles.push(path.slice(cycleStart));
+                }
+            }
+            else if (color.get(neighbor) === WHITE) {
+                dfs(neighbor, path);
+            }
+        }
+        path.pop();
+        color.set(node, BLACK);
+    }
+    for (const skill of skills) {
+        if (color.get(skill.skill_id) === WHITE) {
+            dfs(skill.skill_id, []);
+        }
+    }
+    return cycles;
+}
+//# sourceMappingURL=graph.js.map