# Where to Find the Skill Router Definition for career-ops: Complete Guide

> Find the career ops skill router definition in SKILL.md. This guide explains its role in command routing argument validation and implementation dispatch within the santifer/career-ops repository.

- Repository: [Santiago Fernández de Valderrama/career-ops](https://github.com/santifer/career-ops)
- Tags: how-to-guide
- Published: 2026-08-22

---

**The skill router definition for career-ops is located in [`.agents/skills/career-ops/SKILL.md`](https://github.com/santifer/career-ops/blob/main/.agents/skills/career-ops/SKILL.md), which serves as the single source of truth for command routing, argument validation, and dispatch to concrete implementation files like `scan.mjs` and `openrouter-runner.mjs`.**

The **santifer/career-ops** repository implements a modular AI agent skill for automating job search workflows. Understanding the **skill router definition for career-ops** is essential for extending functionality or debugging command dispatch issues, as it declares how the Agent framework interprets and routes user commands to the correct execution scripts.

## Locating the Skill Router Definition File

The primary **skill router definition for career-ops** resides at [`.agents/skills/career-ops/SKILL.md`](https://github.com/santifer/career-ops/blob/main/.agents/skills/career-ops/SKILL.md). This Markdown file functions as the skill's manifest, registering the `career-ops` namespace with the Agent framework and declaring available sub-commands.

According to the test suite in `test-all.mjs`, the framework loads this router at runtime using:

```js
const routerSkill = readFile('.agents/skills/career-ops/SKILL.md');

```

Placing the router in a [`SKILL.md`](https://github.com/santifer/career-ops/blob/main/SKILL.md) file within the skill's directory keeps routing logic co-located with implementation details, making it discoverable for both the Agent framework and human developers.

## Anatomy of the Router Definition

The [`.agents/skills/career-ops/SKILL.md`](https://github.com/santifer/career-ops/blob/main/.agents/skills/career-ops/SKILL.md) file contains three critical sections that define the skill's interface and behavior.

### Argument Hint Pattern

The router uses a regex pattern to validate incoming commands before dispatch:

```markdown

### Argument-hint

/^\s*(scan|evaluate|apply|pipeline|models|help)\b/

```

This pattern ensures only recognized sub-commands—**scan**, **evaluate**, **apply**, **pipeline**, **models**, or **help**—trigger the skill, filtering invalid input at the routing layer.

### Command Routing Table

The router defines a markdown table mapping commands to their descriptions, which the Agent framework renders as the user-facing help menu:

```markdown
| Command | Description |
|---------|-------------|
| `scan` | Scan Greenhouse APIs for new listings |
| `evaluate <url>` | Evaluate a job posting by URL |
| `apply <report_no>` | Generate draft application form answers |
| `pipeline` | Process all pending URLs from pipeline.md |
| `models` | List available free models |
| `help` | Show the help menu |

```

### Standalone Execution Model

The router explicitly declares itself as **standalone**, meaning it never delegates to sub-agents. Instead, it resolves commands directly to concrete Node.js scripts. This architecture reduces latency by eliminating intermediate routing hops and ensures predictable execution paths.

## Mapping Commands to Implementation Files

The **skill router definition for career-ops** dispatches validated commands to specific `.mjs` entry points within the repository:

- **`career-ops scan`** → `scan.mjs`
- **`career-ops evaluate <url>`** → `openrouter-runner.mjs`
- **`career-ops apply <report#>`** → `openrouter-runner.mjs` (apply logic)
- **`career-ops pipeline`** → Pipeline processing logic
- **`career-ops models`** → Model listing utilities

This mapping ensures that when users execute commands like:

```bash
career-ops scan
career-ops evaluate https://example.com/job
career-ops apply 123

```

The Agent framework invokes the correct implementation script without additional configuration files.

## Validating the Router Configuration

The repository includes validation logic in `test-all.mjs` that asserts the **skill router definition for career-ops** contains the expected routing table entries. This test prevents regression errors when modifying command structures or adding new sub-commands to the [`SKILL.md`](https://github.com/santifer/career-ops/blob/main/SKILL.md) manifest, ensuring the routing table remains synchronized with the actual implementation files.

## Summary

- The **skill router definition for career-ops** lives in [`.agents/skills/career-ops/SKILL.md`](https://github.com/santifer/career-ops/blob/main/.agents/skills/career-ops/SKILL.md) within the santifer/career-ops repository
- It defines an argument-hint regex (`/^\s*(scan|evaluate|apply|pipeline|models|help)\b/`) to validate sub-commands before dispatch
- Commands map directly to `.mjs` files: `scan.mjs` handles job scanning while `openrouter-runner.mjs` manages evaluation and apply workflows
- The router operates in **standalone** mode without sub-agent delegation, resolving directly to concrete scripts
- `test-all.mjs` validates the router configuration to ensure command integrity across updates

## Frequently Asked Questions

### Where is the skill router definition for career-ops located in the repository?

The file is located at [`.agents/skills/career-ops/SKILL.md`](https://github.com/santifer/career-ops/blob/main/.agents/skills/career-ops/SKILL.md) relative to the repository root. This Markdown file serves as the single source of truth for command routing and skill registration with the Agent framework, defining both the command structure and help menu.

### What commands are defined in the career-ops skill router?

The router defines six commands: **scan** (find job listings), **evaluate** (analyze job URLs), **apply** (generate draft applications), **pipeline** (process pending URLs), **models** (list available AI models), and **help** (display usage information). Each command maps to a specific implementation script in the repository root.

### How does the career-ops router validate incoming commands?

The router uses a regex argument-hint pattern (`/^\s*(scan|evaluate|apply|pipeline|models|help)\b/`) defined in the [`SKILL.md`](https://github.com/santifer/career-ops/blob/main/SKILL.md) header to filter valid sub-commands before dispatching to the corresponding `.mjs` entry points, ensuring only supported operations execute.

### Does the career-ops skill router delegate to sub-agents?

No. According to the [`SKILL.md`](https://github.com/santifer/career-ops/blob/main/SKILL.md) file, the router operates in **standalone** mode and resolves commands directly to concrete scripts like `scan.mjs` and `openrouter-runner.mjs`, avoiding sub-agent delegation overhead and reducing execution latency.