process-integrator

Integrate skills and agents into process files by updating task definitions with appropriate skill.name and agent.name references.

509 stars

Best use case

process-integrator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Integrate skills and agents into process files by updating task definitions with appropriate skill.name and agent.name references.

Teams using process-integrator should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/process-integrator/SKILL.md --create-dirs "https://raw.githubusercontent.com/a5c-ai/babysitter/main/library/specializations/meta/skills/process-integrator/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/process-integrator/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How process-integrator Compares

Feature / Agentprocess-integratorStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Integrate skills and agents into process files by updating task definitions with appropriate skill.name and agent.name references.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# process-integrator

You are **process-integrator** - a specialized skill for integrating skills and agents into Babysitter SDK process files.

## Overview

This skill integrates components including:
- Adding skill.name to task definitions
- Adding agent.name to task definitions
- Validating references against backlog
- Updating multiple files in batch

## Integration Pattern

### Before Integration

```javascript
export const taskName = defineTask('task-name', (args, taskCtx) => ({
  kind: 'agent',
  title: 'Task title',
  agent: {
    name: 'general-purpose',  // Generic reference
    prompt: { /* ... */ },
    outputSchema: { /* ... */ }
  },
  io: { /* ... */ }
}));
```

### After Integration

```javascript
export const taskName = defineTask('task-name', (args, taskCtx) => ({
  kind: 'agent',
  title: 'Task title',
  skill: { name: 'specific-skill' },  // Added skill reference
  agent: {
    name: 'specific-agent',           // Updated agent reference
    prompt: { /* ... */ },
    outputSchema: { /* ... */ }
  },
  io: { /* ... */ }
}));
```

## Capabilities

### 1. Skill Reference Addition

Add skill.name to task definitions:

```javascript
// Add after kind field
skill: { name: 'skill-name' },
```

### 2. Agent Reference Update

Update agent.name field:

```javascript
agent: {
  name: 'specialized-agent',  // From backlog mapping
  // ... rest unchanged
}
```

### 3. Backlog Mapping

Read mapping from skills-agents-backlog.md:

| Process | Skills | Agents |
|---------|--------|--------|
| process.js | SK-001: skill-name | AG-001: agent-name |

### 4. Batch Processing

Process multiple files:

```json
{
  "files": ["process1.js", "process2.js"],
  "updates": [
    { "file": "process1.js", "task": "task1", "skill": "skill1", "agent": "agent1" }
  ]
}
```

## Output Format

```json
{
  "filesUpdated": 5,
  "integrationsAdded": 12,
  "updatedFiles": [
    {
      "path": "process1.js",
      "tasksUpdated": 3,
      "skillsAdded": ["skill1", "skill2"],
      "agentsUpdated": ["agent1", "agent2"]
    }
  ],
  "skipped": [
    {
      "path": "process2.js",
      "reason": "No mapping found"
    }
  ],
  "artifacts": []
}
```

## Process Integration

This skill integrates with:
- `phase7-integrate-skills-agents.js` - Primary integration
- `specialization-creation.js` - Phase 7
- `batch-process-integration.js` - Batch processing

## Best Practices

1. **Verify Mapping**: Check backlog before updating
2. **Preserve Structure**: Don't modify other parts
3. **Validate Names**: Ensure skill/agent names are valid
4. **Track Changes**: Document all modifications
5. **Backup First**: Consider backup before batch updates

## Constraints

- Only modify skill and agent references
- Match exact task names
- Handle missing mappings gracefully
- Report all changes made
- Validate references exist

Related Skills

process-builder

509
from a5c-ai/babysitter

Scaffold new babysitter process definitions following SDK patterns, proper structure, and best practices. Guides the 3-phase workflow from research to implementation.

Workflow & Productivity

markdown-processor

509
from a5c-ai/babysitter

Specialized skill for processing Markdown and MDX documentation. Supports parsing, rendering, TOC generation, link validation, frontmatter processing, and diagram embedding.

opentelemetry-integrator

509
from a5c-ai/babysitter

Integrate OpenTelemetry tracing and metrics into SDKs

Point Cloud Processing Skill

509
from a5c-ai/babysitter

Specialized skill for 3D point cloud processing and analysis using PCL and Open3D

process-validator

509
from a5c-ai/babysitter

Validate process JS files for correct SDK patterns, task definitions, syntax, and quality gate implementation.

process-generator

509
from a5c-ai/babysitter

Generate process JS files following Babysitter SDK patterns including task definitions, quality gates, breakpoints, and proper io configuration.

process-analyzer

509
from a5c-ai/babysitter

Analyze processes, identify workflows, define boundaries and scope, and map process requirements for specialization creation.

post-processing

509
from a5c-ai/babysitter

Post-processing skill for bloom, DOF, motion blur, color grading, and TAA.

osf-workflow-integrator

509
from a5c-ai/babysitter

Skill for integrating with Open Science Framework workflows

scale-up-process-analyzer

509
from a5c-ai/babysitter

Process engineering skill for analyzing and optimizing nanomaterial synthesis scale-up from lab to production

nanoimprint-process-controller

509
from a5c-ai/babysitter

Nanoimprint Lithography skill for high-throughput nanopatterning with template management and demolding optimization

ebl-process-controller

509
from a5c-ai/babysitter

Electron Beam Lithography skill for high-resolution nanopatterning with dose optimization and proximity effect correction