autonomous-skill-orchestrator

---

name: autonomous-skill-orchestrator

description: >

Deterministically coordinates autonomous planning and execution across available skills under

strict guardrails. Use only when the user explicitly activates this skill by name to run

autonomously until a stop command is issued. Trigger keywords include: "use autonomous-skill-orchestrator",

"activate autonomous-skill-orchestrator", "start autonomous orchestration".

metadata:

version: "1.1.0"

owner: "user"

---

Activation Criteria

Activate this skill if and only if all conditions below are true:

• -The user explicitly invokes this skill by name or trigger keywords in the current turn.

• -There exists exactly one immediately preceding user command to be treated as the frozen intent.

• -At least one other executable skill is available for coordination.

Do not activate this skill if any condition below is true:

• -The invocation is implicit, inferred, or indirect.

• -The preceding user command is empty, multi-goal, contradictory, or requests clarification.

• -No executable skills are available.

• -The user issues a stop command.

Execution Steps

1. Freeze Intent

- Capture the immediately preceding user command verbatim.

- Store it as immutable intent for the duration of this activation.

- Do not summarize, reinterpret, expand, or decompose the intent.

2. Initialize Control Loop

- Enter a closed-loop execution state owned exclusively by this skill.

- Disable all requests for user input, confirmation, or validation.

- Ignore all user messages except an explicit stop command.

3. Request Plan Proposals

- Invoke the planner skill to produce proposals strictly derived from the frozen intent.

- Require output to contain only:

- A finite, ordered list of features.

- Explicit dependencies between features.

- Explicit assumptions stated as facts, not guesses.

- Reject any proposal that introduces new goals, modifies intent, or omits assumptions.

4. Sanity and Risk Gate

- Evaluate proposals against the following checks:

- Irreversibility of actions.

- Scope expansion beyond frozen intent.

- Use of tools or capabilities not explicitly available.

- Assumptions that cannot be verified from provided context.

- If any check fails, halt immediately.

5. Plan Normalization

- Convert the accepted proposal into a single deterministic execution plan.

- Classify ambiguity as follows:

- Class A (unsafe or unbounded): halt.

- Class B (bounded and resolvable): normalize once.

- Class C (cosmetic or non-operative): ignore.

- Do not re-run normalization or request alternative plans.

6. Execute Plan

- Invoke executor skills to perform each step in order.

- Before each step, verify preconditions explicitly stated in the plan.

- On the first failure or unmet precondition, abort execution immediately.

7. Post-Mortem Recording

- Record only:

- Which step halted execution.

- Which rule or check caused the halt.

- Apply decay so records not repeated are removed over time.

- Do not store goals, plans, preferences, or user behavior patterns.

8. Loop Continuation

- If execution completes successfully, return to Step 3 using the same frozen intent.

- Do not generate new intents or objectives.

9. Stop Condition

- When the user issues an explicit stop command:

- Terminate the control loop immediately.

- Output exactly one dot (.) and no other content.

Ambiguity Handling

• -Missing required information is treated as Class A ambiguity and causes an immediate halt.

• -Conflicting information is treated as Class A ambiguity and causes an immediate halt.

• -Ambiguity resolution is permitted exactly once per cycle and only for Class B cases.

• -No inference, guessing, or user querying is permitted.

Constraints & Non-Goals

• -Must not create, modify, or delete skills.

• -Must not alter the frozen intent.

• -Must not ask the user questions during operation.

• -Must not self-validate plans or actions.

• -Must not continue operation after any halt condition.

• -Must not persist state beyond post-mortem records.

Failure Behavior

If execution cannot be completed safely or correctly:

• -Halt immediately without retry.

• -Produce no output.

• -Await either deactivation or a new explicit activation in a future turn.