> ## Documentation Index
> Fetch the complete documentation index at: https://docs.comet.rpamis.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Compose Native, Classic, and independent workflows

> Choose an application factory and extend or compose Skills within existing acceptance rules.

base selects the application's workflow. Choose by required phases, acceptance, and recovery, not by changing entry Skill prose.

| Type | Public factory | Suitable work |
| - | - | - |
| Native | `createNativeWorkflowApplication` | Add checks for candidates, parents, children, or integration. |
| Classic | `createClassicApplication` | Compose full, hotfix, or tweak Skills and extension steps. |
| Standalone | `createStandaloneApplication` | Define steps, branches, parallel paths, joins, and child workflows. |
| Report sample | createReportApplication | Generate, approve, and publish local reports. |

## Extend Native

Import the factory from @rpamis/comet/applications/native. An extension declares its Skill, artifacts, validator, and candidate, parent, child, or integration scope.

Extension results bind to the current candidate and actual input. Changed requirements, formal Spec, candidate, approval, or artifacts invalidate old results for current checks.

Native retains Builder, independent Verifier, Supervisor, user decisions, and Archive conditions. Extensions add business checks without replacing those responsibilities.

For example, add a team security review after the candidate's independent checks. Use this application-module fragment; securityValidator must be your implemented business validator:

```js theme={null}
import { createNativeWorkflowApplication } from '@rpamis/comet/applications/native';

export function createApplication(context) {
  return createNativeWorkflowApplication(context, {
    extensions: [
      {
        id: 'security-review',
        skillId: 'security-review',
        scopes: ['candidate'],
        artifactRefs: ['reports/security-review.md'],
        validator: securityValidator,
      },
    ],
  });
}
```

Declare actual Skill dependencies and bindings in the manifest, and add artifact contracts for the report. An invalid security report cannot count as a completed extension. Use the corresponding scope for parent, child, or integration results and validate current input and candidate identity.

## Compose Classic

Import the factory from `@rpamis/comet/applications/classic` and choose full, hotfix, or tweak. Replacement Skills receive the original phase input and must deliver the required output. Add steps at allowed checkpoints.

Build, Verify, and Archive machine checks use real commands and current evidence. Missing plans, failed commands, or changed input cannot be replaced with a successful claim.

Classic user decisions, required documents, and archive rules remain effective. Git commits, pushes, and other external operations use actual delivery permission.

Choose the profile, then inspect its actual steps and requirements. This module uses full without replacing phase Skills:

```js theme={null}
import { createClassicApplication } from '@rpamis/comet/applications/classic';

export function createApplication(context) {
  return createClassicApplication(context, { profile: 'full' });
}
```

Manifest base must be classic-full to match the profile. replacements declares actual `stepId` and `skillId`; extensions declares `afterStep`, artifacts, and a validator. Read step names from the original definition, not phase display labels.

## Independent workflows

Independent applications declare their own graph, output Schema, state, transition handlers, executors, and validators. Every transition is declared. Order shared writes or use separate workspaces.

Acceptance depends on the application's own contract. completed may mean publication or completion along a rejected path; inspect business output.

Place workflow and host from the [parallel example](/en/sdk/parallel.md) in a module, then package them with:

```js theme={null}
import { createStandaloneApplication } from '@rpamis/comet/applications';

export function createApplication() {
  return createStandaloneApplication({
    workflows: [workflow],
    executors: [host],
    executorIds: ['host'],
    validators: [],
    validatorRefs: [],
    transitionHandlers: [],
  });
}
```

This fragment follows the existing definitions. The factory checks actual executors, validators, and transition handlers against their declarations and rejects missing execution entries. This standalone factory currently has no evidence validation port. For evidence steps use basic Runtime with explicit `evidenceValidators` or implement a complete custom factory; this sample does not promise every Runtime step type.

## Assemble a confirmed plan

`@rpamis/comet/applications/compiler` provides `prepareWorkflowApplicationPlan` and compileWorkflowApplication. Preparation assembles the actual graph and proposal; confirmation precedes complete package compilation.

The plan pins Skill content, module, input/output, and validation conditions. Prepare and confirm again after document, dependency, or graph changes. Do not substitute another execution module for the confirmed graph.

To avoid manually writing the plan, use [Compose any Skill](/en/skill-creator/overview.md) to inspect real Skills and prepare a proposal. Installation uses [comet application](/en/cli/application.md).

Follow this sequence: inspect Skills, prepare a plan, display and confirm it, compile, validate isolated artifacts, and preview installation. Confirm plan changes again. Test valid and business-invalid samples before distribution. See [real Skill integration](/en/sdk/skill-adaptation.md) for contracts.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.