agentlas-ai/Agentlas-OS

# Agentlas Packaging

## Procedure

1. Inspect the existing source: prompt, repo, ZIP, runtime folder, skill, command,
   or generated agent package.
2. Classify it as single-agent, team-builder, or mixed/unclear.
3. Run `contracts/builder-interview-research-gate.md` when the source behavior,
   target user, tools/plugins, output artifacts, or evaluation bar are unclear.
   Packaging must not turn a shallow prompt into a polished but weak package.
   When the gate runs, research official sources, similar agent repositories or
   comparables, academic/professional theory, and plugin docs before changing
   the source behavior.
4. Preserve useful behavior while adding Agentlas contracts:

# Self-Evolving Single Agent

## Procedure

1. Keep the package as one worker unless the user asks for a team.
2. Run `contracts/builder-interview-research-gate.md` before generation: assess
   supplied context and ask only material gaps, including zero questions when
   sufficient (8-12 only if that many gaps remain). Research official sources, similar agent
   repositories or comparables, academic/professional theory, and plugin docs,
   compare tool/plugin choices, and write the domain-expert synthesis plus
   prompt-performance contract before creating the worker prompt.
3. Add memory architecture even for the single worker:
   - `.agentlas/memory-map.json`;
   - `.agentlas/vault-references.json`;

# Session Agent Builder Skill

Use `modes/session-agent-builder.md` and `agents/40-session-agent-builder/agent.md`
as the canonical route. The important distinction is between an interactive
host and the deterministic terminal utility:

- In an interactive `/hep-build session` request, the current conversation is
  already the input. Do not ask the owner to export or paste JSON/JSONL.
- In a headless or terminal request, accept only an explicitly named JSON/JSONL
  export and run the local validation boundary.

## Interactive route

1. Ask where the new agent should be written. Say that the default is the

# Team Builder Packaging

## Procedure

1. Start with the orchestrator/HQ.
2. Run `contracts/builder-interview-research-gate.md` before writing the roster:
   assess supplied context and ask only material gaps, including zero questions
   when sufficient (8-12 only if that many gaps remain); research official sources, similar agent
   repositories or comparables, academic/professional theory, and plugin docs,
   compare tool/plugin choices, and write the domain-expert synthesis plus
   prompt-performance contract.
3. Add PM Soul or project owner.
4. Add Memory Curator and Memory Ticket handoff.
5. Add Policy Gate, eval judge, and QA/evidence gate.

# Agentlas 시스템 운용 (One 운용 스킬)

도구의 **존재와 이름은 이 문서가 아니라 [INDEX.md](INDEX.md)가 정본**이다(릴리스 빌드가
라이브 레지스트리에서 자동 생성 — 손 목록은 반드시 썩는다). 이 문서는 **절차만** 다룬다.

## 1. 편성 (hep-network) — 로스터 재사용이 항상 먼저

1. `workforce.goal_context`로 활성 로스터부터 확인한다. **재사용으로 충분하면 모집하지 않는다.**
2. 진짜 공백일 때만: 축약(redacted) 워크오더 1장 → `workforce.search_candidates`
   (`sourceScope=network` = local+cloud+hub 연합).
   - ⚠<U+FE0F> `requiredSkills`에 시드 온톨로지 ID를 걸면 실후보 전원이 가짜 결격을 단다(실측).
3. 선발은 **호스트 LLM이** 한다(연합은 점수 매기지 않는다) → `workforce.validate_selection`
   (연합 결과 원본 그대로 — 축약본은 거절됨) → `workforce.prepare_execution`(projectDir 필수).
4. 준비 성공은 자동으로 로스터에 바인딩된다. 바인딩은 명시적 `workforce.complete_goal`까지 유지

# Agentlas Packaging

## Procedure

1. Inspect the existing source: prompt, repo, ZIP, runtime folder, skill, command,
   or generated agent package.
2. Classify it as single-agent, team-builder, or mixed/unclear.
3. Run `contracts/builder-interview-research-gate.md` when the source behavior,
   target user, tools/plugins, output artifacts, or evaluation bar are unclear.
   Packaging must not turn a shallow prompt into a polished but weak package.
   When the gate runs, research official sources, similar agent repositories or
   comparables, academic/professional theory, and plugin docs before changing
   the source behavior.
4. Preserve useful behavior while adding Agentlas contracts:

# Self-Evolving Single Agent

## Procedure

1. Keep the package as one worker unless the user asks for a team.
2. Run `contracts/builder-interview-research-gate.md` before generation: assess
   supplied context and ask only material gaps, including zero questions when
   sufficient (8-12 only if that many gaps remain). Research official sources, similar agent
   repositories or comparables, academic/professional theory, and plugin docs,
   compare tool/plugin choices, and write the domain-expert synthesis plus
   prompt-performance contract before creating the worker prompt.
3. Add memory architecture even for the single worker:
   - `.agentlas/memory-map.json`;
   - `.agentlas/vault-references.json`;

# Session Agent Builder Skill

Use `modes/session-agent-builder.md` and `agents/40-session-agent-builder/agent.md`
as the canonical route. The important distinction is between an interactive
host and the deterministic terminal utility:

- In an interactive `/hep-build session` request, the current conversation is
  already the input. Do not ask the owner to export or paste JSON/JSONL.
- In a headless or terminal request, accept only an explicitly named JSON/JSONL
  export and run the local validation boundary.

## Interactive route

1. Ask where the new agent should be written. Say that the default is the

# Team Builder Packaging

## Procedure

1. Start with the orchestrator/HQ.
2. Run `contracts/builder-interview-research-gate.md` before writing the roster:
   assess supplied context and ask only material gaps, including zero questions
   when sufficient (8-12 only if that many gaps remain); research official sources, similar agent
   repositories or comparables, academic/professional theory, and plugin docs,
   compare tool/plugin choices, and write the domain-expert synthesis plus
   prompt-performance contract.
3. Add PM Soul or project owner.
4. Add Memory Curator and Memory Ticket handoff.
5. Add Policy Gate, eval judge, and QA/evidence gate.

# Agentlas Build (/agentlas-build, /hep-build)

Design, assemble, and package installable single agents or multi-agent teams.
Alias for `/agentlas build` and `/hep-build`.

Guides the workflow through:
1. Mode classification (`single-agent-creator`, `team-builder`, `agentlas-packager`, `session-agent-builder`)
2. Interview/research gate
3. Routing card and soul authoring
4. Runtime adapter generation (Codex, Claude, Gemini, Antigravity)
5. Package verification

# Agentlas Cloud Workforce (/agentlas-cloud, /hep-cloud)

Staff specialist roles specifically from the owner's private Agentlas Cloud repository.
Alias for `hephaestus-cloud` and `/agentlas cloud`.

See [hephaestus-cloud](hephaestus-cloud/SKILL.md) for full execution protocol.

# Agentlas Network Workforce (/agentlas-network, /hep-network)

Federated Local + Cloud + Hub workforce staffing orchestrator.
Alias for `hephaestus-network` and `/agentlas network`.

## Required MCP sequence
```text
workforce.search_candidates(sourceScope="network")
workforce.validate_selection(workOrder=..., selection=...)
workforce.prepare_execution(workOrder=..., selection=..., federatedSelection=..., projectDir=..., goalId=activeGoalId?)
workforce.validate_execution_receipt(receipt=..., executionPlan=..., toolInventory=...)
```

See [hephaestus-network](hephaestus-network/SKILL.md) for full execution protocol.

# Agentlas 시스템 운용 (One 운용 스킬)

도구의 **존재와 이름은 이 문서가 아니라 [INDEX.md](INDEX.md)가 정본**이다(릴리스 빌드가
라이브 레지스트리에서 자동 생성 — 손 목록은 반드시 썩는다). 이 문서는 **절차만** 다룬다.

## 1. 편성 (hep-network) — 로스터 재사용이 항상 먼저

1. `workforce.goal_context`로 활성 로스터부터 확인한다. **재사용으로 충분하면 모집하지 않는다.**
2. 진짜 공백일 때만: 축약(redacted) 워크오더 1장 → `workforce.search_candidates`
   (`sourceScope=network` = local+cloud+hub 연합).
   - ⚠<U+FE0F> `requiredSkills`에 시드 온톨로지 ID를 걸면 실후보 전원이 가짜 결격을 단다(실측).
3. 선발은 **호스트 LLM이** 한다(연합은 점수 매기지 않는다) → `workforce.validate_selection`
   (연합 결과 원본 그대로 — 축약본은 거절됨) → `workforce.prepare_execution`(projectDir 필수).
4. 준비 성공은 자동으로 로스터에 바인딩된다. 바인딩은 명시적 `workforce.complete_goal`까지 유지

# Agentlas Stormbreaker Loop (/agentlas-storm, /hep-storm)

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust, verifier-first execution loop.
Alias for `hephaestus-storm` and `/agentlas storm`.

See [hephaestus-storm](hephaestus-storm/SKILL.md) for full execution protocol.

# Agentlas Upload (/agentlas-upload, /hep-upload)

Package security scan and distribution gate for Agentlas agents and teams.
Alias for `hephaestus-upload` and `/agentlas upload`.

See [hephaestus-upload](hephaestus-upload/SKILL.md) for full execution protocol.

# Hephaestus Build

## Procedure

1. Treat this as the public Codex build surface. Do not expose or ask the user
   to invoke the older internal support skill names.
2. Resolve the trusted engine root before reading any build contract:

   ```bash
   ENGINE=""
   for candidate in \
     "${CODEX_PLUGIN_ROOT:-}" \
     "${CLAUDE_PLUGIN_ROOT:-}" \
     "${PLUGIN_ROOT:-}" \

# Hephaestus Cloud Routing (my own cloud / 보관함)

Route the request through the signed-in user's OWN Agentlas cloud packages only.
The active host LLM remains the staffing decision-maker; Cloud supplies a
content menu and exact BYOM releases.

## 0. Scope rule

`/hep-cloud` is owner-scoped: it queries ONLY the authenticated owner's
own cloud packages (보관함) through Core's typed `sourceScope: "cloud"`. It does **not**
search the public marketplace and does **not** search local private/plugin
cards.

- The user's own Cloud packages are restorable/owned by them. Entitlement,

# Hephaestus Agent Workforce Network

<!-- prompt-module: {"id":"skill.network.host-execution","revision":2,"stability":"fixed-policy","changeTriggers":["release"],"order":0} -->

The active host LLM staffs the task. Agentlas Core federates content menus from
registered Local, owner Cloud, and public Hub inventory. No source and no
deterministic layer is the decision-maker or a server-side LLM executor.

Source scopes are exact:

- `network`: Local + Cloud + Hub;
- `local`: registered Local packages only;
- `cloud`: the signed-in owner's Cloud packages only;
- `hub`: public Hub packages only.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# Hephaestus Stormbreaker Loop

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop. Unlike a one-shot answer or a generic parallel
fan-out, Stormbreaker **routes the goal to real Agentlas specialists**, structures
the work as a dependency-ordered pipeline fabric, drives each work packet as a
**hardened goal loop** (it does not stall, run away, or claim false success), and
**refuses to report success without evidence**. Never guess an agent yourself when
this skill is active — the router or Hub decides the workforce.

## Core-owned Goal + UltraCode harness

# Hephaestus Upload (Cloud or Agentlas Hub)

<!-- prompt-module: {"id":"skill.upload.host-execution","revision":2,"stability":"versioned-content","changeTriggers":["release","skill-package"],"channel":"system"} -->

Publish a finished Agentlas package. This is a WRITE surface: a Hub upload is
public and other people can borrow it, so the destination question comes before
any packaging or API call.

Upload is deliberately NOT folded into `/hep-network`. Network staffs a roster
(a read), upload publishes an artifact (a write that is hard to take back);
merging them would let "find me an agent" end in an accidental publish.

## 1. Ask the destination first — always

# Routing Card Field Spec — what goes in every field, and where it lands

One card, four builders. `10-single-agent-builder`, `20-multi-agent-team-builder`,
`30-agentlas-packager`, and `40-session-agent-builder` differ in what they
assemble, but the routing card is the same artifact with the same rules in all
four. This file is the reference
they share, and `templates/routing-card.example.json` is a complete card that
passes `schemas/routing-card.schema.json`.

## Why the fields behave the way they do

**The real matching is sentence-to-sentence.** The slot's `task` text is
   compared semantically against the card's `summary`. A card whose summary
   names its actual deliverable outranks a card with a perfect id list.

# Session Agent Builder Skill

Use `modes/session-agent-builder.md` and `agents/40-session-agent-builder/agent.md`
as the canonical route. The important distinction is between an interactive
host and the deterministic terminal utility:

- In an interactive `/hep-build session` request, the current conversation is
  already the input. Do not ask the owner to export or paste JSON/JSONL.
- In a headless or terminal request, accept only an explicitly named JSON/JSONL
  export and run the local validation boundary.

## Interactive route

1. Ask where the new agent should be written. Say that the default is the

# Hephaestus Cloud Routing (my own cloud / 보관함)

Route the request through the signed-in user's OWN Agentlas cloud packages only.
The active host LLM remains the staffing decision-maker; Cloud supplies a
content menu and exact BYOM releases.

## 0. Scope rule

`/hep-cloud` is owner-scoped: it queries ONLY the authenticated owner's
own cloud packages (보관함) through Core's typed `sourceScope: "cloud"`. It does **not**
search the public marketplace and does **not** search local private/plugin
cards.

- The user's own Cloud packages are restorable/owned by them. Entitlement,

# Hephaestus Agent Workforce Network

<!-- prompt-module: {"id":"skill.network.host-execution","revision":2,"stability":"fixed-policy","changeTriggers":["release"],"order":0} -->

The active host LLM staffs the task. Agentlas Core federates content menus from
registered Local, owner Cloud, and public Hub inventory. No source and no
deterministic layer is the decision-maker or a server-side LLM executor.

Source scopes are exact:

- `network`: Local + Cloud + Hub;
- `local`: registered Local packages only;
- `cloud`: the signed-in owner's Cloud packages only;
- `hub`: public Hub packages only.

# Hephaestus Upload (Cloud or Agentlas Hub)

<!-- prompt-module: {"id":"skill.upload.host-execution","revision":2,"stability":"versioned-content","changeTriggers":["release","skill-package"],"channel":"system"} -->

Publish a finished Agentlas package. This is a WRITE surface: a Hub upload is
public and other people can borrow it, so the destination question comes before
any packaging or API call.

Upload is deliberately NOT folded into `/hep-network`. Network staffs a roster
(a read), upload publishes an artifact (a write that is hard to take back);
merging them would let "find me an agent" end in an accidental publish.

## 1. Ask the destination first — always

# Hephaestus Cloud Routing (my own cloud / 보관함)

Route the request through the signed-in user's OWN Agentlas cloud packages only.
The active host LLM remains the staffing decision-maker; Cloud supplies a
content menu and exact BYOM releases.

## 0. Scope rule

`/hep-cloud` is owner-scoped: it queries ONLY the authenticated owner's
own cloud packages (보관함) through Core's typed `sourceScope: "cloud"`. It does **not**
search the public marketplace and does **not** search local private/plugin
cards.

- The user's own Cloud packages are restorable/owned by them. Entitlement,

# Hephaestus Agent Workforce Network

<!-- prompt-module: {"id":"skill.network.host-execution","revision":2,"stability":"fixed-policy","changeTriggers":["release"],"order":0} -->

The active host LLM staffs the task. Agentlas Core federates content menus from
registered Local, owner Cloud, and public Hub inventory. No source and no
deterministic layer is the decision-maker or a server-side LLM executor.

Source scopes are exact:

- `network`: Local + Cloud + Hub;
- `local`: registered Local packages only;
- `cloud`: the signed-in owner's Cloud packages only;
- `hub`: public Hub packages only.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# Hephaestus Stormbreaker Loop

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop. Unlike a one-shot answer or a generic parallel
fan-out, Stormbreaker **routes the goal to real Agentlas specialists**, structures
the work as a dependency-ordered pipeline fabric, drives each work packet as a
**hardened goal loop** (it does not stall, run away, or claim false success), and
**refuses to report success without evidence**. Never guess an agent yourself when
this skill is active — the router or Hub decides the workforce.

## Core-owned Goal + UltraCode harness

# Hephaestus Upload (Cloud or Agentlas Hub)

<!-- prompt-module: {"id":"skill.upload.host-execution","revision":2,"stability":"versioned-content","changeTriggers":["release","skill-package"],"channel":"system"} -->

Publish a finished Agentlas package. This is a WRITE surface: a Hub upload is
public and other people can borrow it, so the destination question comes before
any packaging or API call.

Upload is deliberately NOT folded into `/hep-network`. Network staffs a roster
(a read), upload publishes an artifact (a write that is hard to take back);
merging them would let "find me an agent" end in an accidental publish.

## 1. Ask the destination first — always

# agentlas-browser

Identical to `/skill:hep-browser` and `/agentlas browser <request>`. Locate the
sibling skill directory `hep-browser` (i.e. `../hep-browser/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-browser` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-browser/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-build

Identical to `/skill:hep-build` and `/agentlas build <request>`. Locate the
sibling skill directory `hep-build` (i.e. `../hep-build/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-build` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-build/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-call

Identical to `/skill:hep-call` and `/agentlas call <request>`. Locate the
sibling skill directory `hep-call` (i.e. `../hep-call/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-call` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-call/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-cloud

Identical to `/skill:hep-cloud` and `/agentlas cloud <request>`. Locate the
sibling skill directory `hep-cloud` (i.e. `../hep-cloud/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-cloud` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-cloud/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-hub

Identical to `/skill:hep-hub` and `/agentlas hub <request>`. Locate the
sibling skill directory `hep-hub` (i.e. `../hep-hub/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-hub` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-hub/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-local

Identical to `/skill:hep-local` and `/agentlas local <request>`. Locate the
sibling skill directory `hep-local` (i.e. `../hep-local/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-local` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-local/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-network

Identical to `/skill:hep-network` and `/agentlas network <request>`. Locate the
sibling skill directory `hep-network` (i.e. `../hep-network/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-network` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-network/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-search

Identical to `/skill:hep-search` and `/agentlas search <request>`. Locate the
sibling skill directory `hep-search` (i.e. `../hep-search/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-search` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-search/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-storm

Identical to `/skill:hep-storm` and `/agentlas storm <request>`. Locate the
sibling skill directory `hep-storm` (i.e. `../hep-storm/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-storm` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-storm/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

# agentlas-upload

Identical to `/skill:hep-upload` and `/agentlas upload <request>`. Locate the
sibling skill directory `hep-upload` (i.e. `../hep-upload/SKILL.md` relative to
this file, under the same `kimi/skills/` root this skill was loaded from), read
its `SKILL.md`, and follow its instructions exactly — treating everything typed
after `/skill:agentlas-upload` as that command's request.

Do not improvise a separate workflow and do not summarize `hep-upload/SKILL.md`
from memory; that file is the sole authority for this command's behavior.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# /hep-browser

Use this when the task needs a real browser, page rendering, login-visible state,
click/form behavior, or JS-heavy evidence. Prefer the Agentlas browser hardpoint
first; do not route browser work through generic research commands unless this
command reports that the hardpoint is unavailable.

Behavior:
- `/hep-browser <url>` reads a rendered browser snapshot.
- `/hep-browser <url> "<instruction>"` or `/hep-browser <url> --act "<instruction>"`
  performs browser automation through `browser.agent_cli`, then captures a
  snapshot.
- If the Agentlas Browser CDP port is already live, the command attaches to it

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

<!-- prompt-module: {"id":"os.commands.build-body","revision":2,"stability":"versioned-content","changeTriggers":["release"],"channel":"user"} -->

# /hep-build

Use Hephaestus as the Agentlas builder surface:

- create a new single agent
- create a multi-agent team
- package an existing Claude/Codex/Antigravity workspace into Agentlas architecture
- analyze the current interactive session and build its reusable agent
- compile an explicitly exported session for terminal or headless replay
- repair generated Agentlas command files
- open `ontology` as the Knowledge/Memory panel

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.
# /hep-call

Call the exact agents named by the user. This prepares BYOM runtime bundles and
receipts; your own model still performs the actual model/tool execution.

Syntax: `/hep-call agent-a, agent-b {context}`. The text before `{` is the
agent list; the text inside braces is the context. If braces are omitted, the
first token is the agent list and the rest is context.

## If the user wants it to keep running

Public Hub agent calls are free. Explain that scheduled work still uses the
host's own model, API keys, permissions, and runtime capacity. Do not quote or

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# /hep-cloud

Act as the temporary top-level workforce orchestrator. Use the local Agentlas
OS MCP server `hephaestus-network` and call the Workforce tools with exact
`sourceScope: "cloud"`. This command may search only packages owned by the
signed-in Agentlas account. It must not add Local or public Hub candidates.

Every unpinned Cloud discovery asks the owner-scoped source for its current
menu; a client success-cache entry must not hide a newly published, replaced,
or removed package. After validation, preparation remains pinned to the exact
Cloud release selected from that discovery.

Before the first Cloud source call, reuse the installed Agentlas sign-in.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# /hep-hub

Use the local Agentlas OS MCP server `hephaestus-network` and call the
Workforce tools with exact `sourceScope: "hub"`. This is public Hub only; it
must not add registered Local or owner Cloud candidates.

## First decide which of the two shapes this is

**One named agent.** The argument names a single agent — a slug, or an
unmistakable name with no task described around it (`ktx-book`,
`use ktx-book`). The user is asking to *use that agent*, not to have a team
staffed, so do not make them sit through a staffing ceremony to get there:

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# /hep-local

Raw request: `$ARGUMENTS`

Act as the temporary top-level workforce orchestrator. Use the local Agentlas
OS MCP server `hephaestus-network` and call the Workforce tools with exact
`sourceScope: "local"`. Before every unpinned discovery, Core refreshes the
current safe snapshot for each active registered Local source, creating a new
release when the source folder changed. This command searches only that
registered Local inventory; it must not add owner Cloud or public Hub
candidates. A prepared or goal-bound selection remains pinned to its exact
release. `network reindex` rebuilds the card cache but is not the release
refresh mechanism, and a new source still requires explicit registration.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

<!-- prompt-module: {"id":"os.commands.network-body","revision":2,"stability":"versioned-content","changeTriggers":["release"],"channel":"user"} -->

# /hep-network

<!-- prompt-module: {"id":"command.hep-network.host-execution","revision":2,"stability":"fixed-policy","changeTriggers":["release"],"order":0} -->

You are the active top-level workforce orchestrator. Use the local Agentlas
OS MCP server named `hephaestus-network`, the only host-visible Workforce MCP.
Core reaches Cloud and Hub through its internal upstream client. Network means all registered
Local agents, the signed-in owner's Cloud agents, and public Hub agents.

Before every unpinned discovery, Core refreshes the current safe snapshot for
each active registered Local source. A changed Local folder therefore becomes a

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.
# /hep-search

Find matching agents **without calling them**. Return two sections: my Agentlas
Cloud packages first, then the public Agentlas Hub.

The request is the exact text the user typed after `/hep-search`.

## How to run

Run the shell block below **verbatim**, replacing only the `REQUEST` value. The
runner is resolved by **absolute path** — nothing to install, nothing to add to
`PATH`.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.
# /hep-storm

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop — inside this workspace. Unlike a
one-shot answer or a generic parallel fan-out, Stormbreaker **routes the goal to
real Agentlas specialists**, structures the work as a dependency-ordered pipeline
fabric, drives each work packet as a **hardened goal loop** (it does not stall,
run away, or claim false success), and **refuses to report success without
evidence**. Also triggered by `@Hephaestus storm <goal>`.

Use it for loop-worthy work: apps, sites, agents, automations, debugging,
multi-step research, data/report generation — anything with files, tools, tests,
or external verification. Trivial questions should be answered directly, not

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.
# /hep-upload

Upload an Agentlas agent package. The argument is the exact text the user typed
after `/hep-upload` — usually an agent folder, possibly empty.

> Guardrails: do NOT diagnose `command not found`/`PATH`, do NOT edit
> `~/.zshrc`, and do NOT create/commit/stash/push any git branch or claim you
> did. If the runner is missing, say so and stop — never fabricate an upload.

## Step 1 — Ask the destination first

Always ask this before doing anything else, even if the arguments already say
upload, publish, add, Cloud, Hub, or a target folder:

# Hephaestus Cloud Routing (my own cloud / 보관함)

Route the request through the signed-in user's OWN Agentlas cloud packages only.
The active host LLM remains the staffing decision-maker; Cloud supplies a
content menu and exact BYOM releases.

## 0. Scope rule

`/hep-cloud` is owner-scoped: it queries ONLY the authenticated owner's
own cloud packages (보관함) through Core's typed `sourceScope: "cloud"`. It does **not**
search the public marketplace and does **not** search local private/plugin
cards.

- The user's own Cloud packages are restorable/owned by them. Entitlement,

# Hephaestus Agent Workforce Network

<!-- prompt-module: {"id":"skill.network.host-execution","revision":2,"stability":"fixed-policy","changeTriggers":["release"],"order":0} -->

The active host LLM staffs the task. Agentlas Core federates content menus from
registered Local, owner Cloud, and public Hub inventory. No source and no
deterministic layer is the decision-maker or a server-side LLM executor.

Source scopes are exact:

- `network`: Local + Cloud + Hub;
- `local`: registered Local packages only;
- `cloud`: the signed-in owner's Cloud packages only;
- `hub`: public Hub packages only.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# Hephaestus Stormbreaker Loop

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop. Unlike a one-shot answer or a generic parallel
fan-out, Stormbreaker **routes the goal to real Agentlas specialists**, structures
the work as a dependency-ordered pipeline fabric, drives each work packet as a
**hardened goal loop** (it does not stall, run away, or claim false success), and
**refuses to report success without evidence**. Never guess an agent yourself when
this skill is active — the router or Hub decides the workforce.

## Core-owned Goal + UltraCode harness

# Hephaestus Upload (Cloud or Agentlas Hub)

<!-- prompt-module: {"id":"skill.upload.host-execution","revision":2,"stability":"versioned-content","changeTriggers":["release","skill-package"],"channel":"system"} -->

Publish a finished Agentlas package. This is a WRITE surface: a Hub upload is
public and other people can borrow it, so the destination question comes before
any packaging or API call.

Upload is deliberately NOT folded into `/hep-network`. Network staffs a roster
(a read), upload publishes an artifact (a write that is hard to take back);
merging them would let "find me an agent" end in an accidental publish.

## 1. Ask the destination first — always

# Agentlas Packaging

## Procedure

1. Inspect the existing source: prompt, repo, ZIP, runtime folder, skill, command,
   or generated agent package.
2. Classify it as single-agent, team-builder, or mixed/unclear.
3. Run `contracts/builder-interview-research-gate.md` when the source behavior,
   target user, tools/plugins, output artifacts, or evaluation bar are unclear.
   Packaging must not turn a shallow prompt into a polished but weak package.
   When the gate runs, research official sources, similar agent repositories or
   comparables, academic/professional theory, and plugin docs before changing
   the source behavior.
4. Preserve useful behavior while adding Agentlas contracts:

# Self-Evolving Single Agent

## Procedure

1. Keep the package as one worker unless the user asks for a team.
2. Run `contracts/builder-interview-research-gate.md` before generation: assess
   supplied context and ask only material gaps, including zero questions when
   sufficient (8-12 only if that many gaps remain). Research official sources, similar agent
   repositories or comparables, academic/professional theory, and plugin docs,
   compare tool/plugin choices, and write the domain-expert synthesis plus
   prompt-performance contract before creating the worker prompt.
3. Add memory architecture even for the single worker:
   - `.agentlas/memory-map.json`;
   - `.agentlas/vault-references.json`;

# Session Agent Builder Skill

Use `modes/session-agent-builder.md` and `agents/40-session-agent-builder/agent.md`
as the canonical route. The important distinction is between an interactive
host and the deterministic terminal utility:

- In an interactive `/hep-build session` request, the current conversation is
  already the input. Do not ask the owner to export or paste JSON/JSONL.
- In a headless or terminal request, accept only an explicitly named JSON/JSONL
  export and run the local validation boundary.

## Interactive route

1. Ask where the new agent should be written. Say that the default is the

# Team Builder Packaging

## Procedure

1. Start with the orchestrator/HQ.
2. Run `contracts/builder-interview-research-gate.md` before writing the roster:
   assess supplied context and ask only material gaps, including zero questions
   when sufficient (8-12 only if that many gaps remain); research official sources, similar agent
   repositories or comparables, academic/professional theory, and plugin docs,
   compare tool/plugin choices, and write the domain-expert synthesis plus
   prompt-performance contract.
3. Add PM Soul or project owner.
4. Add Memory Curator and Memory Ticket handoff.
5. Add Policy Gate, eval judge, and QA/evidence gate.

# Agent Team Design

## Procedure

1. Define the user job and target runtime.
2. Start with one agent. Add team roles only when routing, memory, review,
   policy, or parallel ownership is useful.
3. Use a visible public tree:
   - `agents/10-single-agent-builder/agent.md`
   - `agents/20-multi-agent-team-builder/agent.md`
   - `agents/30-agentlas-packager/agent.md`
   - `agents/40-session-agent-builder/agent.md`
4. Add `skills/<capability>/SKILL.md` for reusable procedures.
5. Add `.agentlas/company-blueprint.json` for topology.

# Agentlas Core & Unified Command System

Single entry point for every Agentlas subsystem and capability. Both hyphenated forms (`/agentlas-<command>`) and space-separated forms (`/agentlas <command>`) are fully supported and correspond 1:1 to the Hephaestus (`/hep-<command>`) shortcuts:

| Hyphenated Command | Spaced Command | Hephaestus Shortcut | Description |
|---|---|---|---|
| `/agentlas-network <goal>` | `/agentlas network <goal>` | `/hep-network <goal>` | Staff federated Local + Cloud + Hub workforce |
| `/agentlas-storm <goal>` | `/agentlas storm <goal>` | `/hep-storm <goal>` | Run force-robust Stormbreaker execution loop |
| `/agentlas-build <request>` | `/agentlas build <request>` | `/hep-build <request>` | Design & package single agents or multi-agent teams |
| `/agentlas-goal <request>` | `/agentlas goal <request>` | `/hep-goal <request>` | Manage a goal plan and its progress |
| `/agentlas-one on\|off` | `/agentlas one on\|off` | `/hep-one on\|off` | Toggle Hope persistent personal agent mode |
| `/agentlas-upload <folder>` | `/agentlas upload <folder>` | `/hep-upload <folder>` | Gate scan & publish agent/team packages |
| `/agentlas-cloud <goal>` | `/agentlas cloud <goal>` | `/hep-cloud <goal>` | Staff from owner's private Cloud packages |
| `/agentlas-hub <goal>` | `/agentlas hub <goal>` | `/hep-hub <goal>` | Staff from public Agentlas Hub marketplace |

# Agentlas Auto-Activation

Use this skill when a local runtime should activate Agentlas project continuity
for a folder.

## Procedure

1. For explicit activation, call `hephaestus project ensure --project <folder>`
   from Agentlas Core.
2. For automatic activation, require a trusted writable host, an allowed root,
   a workspace marker, and host-side opt-in. Passive search, read-only work,
   and MCP requests do not imply write consent.
3. Never create project state in the user's home directory, filesystem root, or
   outside the host's allowed project roots.

# Agentlas Browser Automation (/agentlas-browser, /hep-browser)

Browser interaction and headless/CDP automation runner for Agentlas tasks.
Alias for `/hep-browser` and `/agentlas browser`.

# Agentlas Build (/agentlas-build, /hep-build)

Design, assemble, and package installable single agents or multi-agent teams.
Alias for `/agentlas build` and `/hep-build`.

Guides the workflow through:
1. Mode classification (`single-agent-creator`, `team-builder`, `agentlas-packager`, `session-agent-builder`)
2. Interview/research gate
3. Routing card and soul authoring
4. Runtime adapter generation (Codex, Claude, Antigravity)
5. Package verification

When the request is `session` in an interactive host, use the current
conversation as the source, ask for an alternate destination only if needed,

# Agentlas Call (/agentlas-call, /hep-call)

Directly invoke specific named agents or teams from Agentlas Hub or Cloud.
Alias for `/hep-call` and `/agentlas call`.

# Agentlas Cloud Workforce (/agentlas-cloud, /hep-cloud)

Staff specialist roles specifically from the owner's private Agentlas Cloud repository.
Alias for `hephaestus-cloud` and `/agentlas cloud`.

See [hephaestus-cloud](../hephaestus-cloud/SKILL.md) for full execution protocol.

# Agentlas Hub Public Workforce (/agentlas-hub, /hep-hub)

Staff specialist roles specifically from the public Agentlas Hub repository.
Alias for `/hep-hub` and `/agentlas hub`.

# Agentlas Local Workforce (/agentlas-local, /hep-local)

Staff specialist roles specifically from locally registered packages in `~/.agentlas/workforce/local`.
Alias for `/hep-local` and `/agentlas local`.

# Agentlas Network Workforce (/agentlas-network, /hep-network)

Federated Local + Cloud + Hub workforce staffing orchestrator.
Alias for `hephaestus-network` and `/agentlas network`.

## Required MCP sequence
```text
workforce.search_candidates(sourceScope="network")
workforce.validate_selection(workOrder=..., selection=...)
workforce.prepare_execution(workOrder=..., selection=..., federatedSelection=..., projectDir=..., goalId=activeGoalId?)
workforce.validate_execution_receipt(receipt=..., executionPlan=..., toolInventory=...)
```

See [hephaestus-network](../hephaestus-network/SKILL.md) for full execution protocol.

# Agentlas One (/agentlas-one)

Persistent personal agent operating mode control. The agent's name is whatever the
owner chose (`agentlas-one name <name>`); it is never fixed in this document.
Toggle via `/agentlas-one on` or `/agentlas-one off`.

## Commands

These are the verbs the runner actually accepts (`bin/agentlas-one`). Anything not
listed here does not exist — do not invent one.

- `install` — put the runner on PATH and wire the status line.
- `on [name]` / `off` — enable or disable the persistent mode.
- `name <name>` — rename the agent. This never turns it on.

# Agentlas 시스템 운용 (One 운용 스킬)

도구의 **존재와 이름은 이 문서가 아니라 [INDEX.md](INDEX.md)가 정본**이다(릴리스 빌드가
라이브 레지스트리에서 자동 생성 — 손 목록은 반드시 썩는다). 이 문서는 **절차만** 다룬다.

## 1. 편성 (hep-network) — 로스터 재사용이 항상 먼저

1. `workforce.goal_context`로 활성 로스터부터 확인한다. **재사용으로 충분하면 모집하지 않는다.**
2. 진짜 공백일 때만: 축약(redacted) 워크오더 1장 → `workforce.search_candidates`
   (`sourceScope=network` = local+cloud+hub 연합).
   - ⚠<U+FE0F> `requiredSkills`에 시드 온톨로지 ID를 걸면 실후보 전원이 가짜 결격을 단다(실측).
3. 선발은 **호스트 LLM이** 한다(연합은 점수 매기지 않는다) → `workforce.validate_selection`
   (연합 결과 원본 그대로 — 축약본은 거절됨) → `workforce.prepare_execution`(projectDir 필수).
4. 준비 성공은 자동으로 로스터에 바인딩된다. 바인딩은 명시적 `workforce.complete_goal`까지 유지

# Agentlas Packaging

## Procedure

1. Inspect the existing source: prompt, repo, ZIP, runtime folder, skill, command,
   or generated agent package.
2. Classify it as single-agent, team-builder, or mixed/unclear.
3. Run `contracts/builder-interview-research-gate.md` when the source behavior,
   target user, tools/plugins, output artifacts, or evaluation bar are unclear.
   Packaging must not turn a shallow prompt into a polished but weak package.
   When the gate runs, research official sources, similar agent repositories or
   comparables, academic/professional theory, and plugin docs before changing
   the source behavior.
4. Preserve useful behavior while adding Agentlas contracts:

# Agentlas Search (/agentlas-search, /hep-search)

Search across Local, Cloud, and Hub agent catalogues.
Alias for `/hep-search` and `/agentlas search`.

# Agentlas Security Scan (2-Stage)

Plan §6.2: stage 1 is static rule screening, stage 2 is a judgment made by the
user's own LLM session (BYOK). The Cloud server never calls an LLM (v1
Non-Goal: no server-side model execution). You — the agent running this skill —
are the stage-2 judge.

## Stage 1 — Static scan

1. Run `bin/hephaestus security scan <agent-folder>`.
2. The report at `.agentlas/security-scan.json` lists rule-based findings
   (`"source": "static"`) and a verdict: `BLOCK` > `WARN` > `PASS`.

## Stage 2 — LLM judgment (BYOK)

# Agentlas Stormbreaker Loop (/agentlas-storm, /hep-storm)

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust, verifier-first execution loop.
Alias for `hephaestus-storm` and `/agentlas storm`.

See [hephaestus-storm](../hephaestus-storm/SKILL.md) for full execution protocol.

# Agentlas Upload (/agentlas-upload, /hep-upload)

Package security scan and distribution gate for Agentlas agents and teams.
Alias for `hephaestus-upload` and `/agentlas upload`.

See [hephaestus-upload](../hephaestus-upload/SKILL.md) for full execution protocol.

# Clarify Question Loop

Ask only questions that change the generated package, runtime adapter, safety
boundary, or public/private release decision.

For `/hep-build` creation or behavior-changing packaging, this is not a
substitute for the Builder Interview and Research Gate in
`contracts/builder-interview-research-gate.md`. Run that gate first: assess the
supplied context and ask only material gaps, including zero questions when
sufficient (8-12 only if that many gaps remain); research similar agent repositories or comparables and
academic/professional theory, then use this clarify loop only for the remaining
narrow ambiguities.

## Procedure

# Hephaestus Cloud Routing (my own cloud / 보관함)

Route the request through the signed-in user's OWN Agentlas cloud packages only.
The active host LLM remains the staffing decision-maker; Cloud supplies a
content menu and exact BYOM releases.

## 0. Scope rule

`/hep-cloud` is owner-scoped: it queries ONLY the authenticated owner's
own cloud packages (보관함) through Core's typed `sourceScope: "cloud"`. It does **not**
search the public marketplace and does **not** search local private/plugin
cards.

- The user's own Cloud packages are restorable/owned by them. Entitlement,

# Hephaestus Agent Workforce Network

<!-- prompt-module: {"id":"skill.network.host-execution","revision":2,"stability":"fixed-policy","changeTriggers":["release"],"order":0} -->

The active host LLM staffs the task. Agentlas Core federates content menus from
registered Local, owner Cloud, and public Hub inventory. No source and no
deterministic layer is the decision-maker or a server-side LLM executor.

Source scopes are exact:

- `network`: Local + Cloud + Hub;
- `local`: registered Local packages only;
- `cloud`: the signed-in owner's Cloud packages only;
- `hub`: public Hub packages only.

Update fallback: 자동 업데이트가 안 되면 `hephaestus update`를 한 번 실행하세요. 업데이트하지 않아도 현재 버전 명령은 그대로 동작합니다.

# Hephaestus Stormbreaker Loop

Drive a goal through the **Stormbreaker Loop** — Hephaestus' force-robust,
verifier-first execution loop. Unlike a one-shot answer or a generic parallel
fan-out, Stormbreaker **routes the goal to real Agentlas specialists**, structures
the work as a dependency-ordered pipeline fabric, drives each work packet as a
**hardened goal loop** (it does not stall, run away, or claim false success), and
**refuses to report success without evidence**. Never guess an agent yourself when
this skill is active — the router or Hub decides the workforce.

## Core-owned Goal + UltraCode harness

# Hephaestus Upload (Cloud or Agentlas Hub)

<!-- prompt-module: {"id":"skill.upload.host-execution","revision":2,"stability":"versioned-content","changeTriggers":["release","skill-package"],"channel":"system"} -->

Publish a finished Agentlas package. This is a WRITE surface: a Hub upload is
public and other people can borrow it, so the destination question comes before
any packaging or API call.

Upload is deliberately NOT folded into `/hep-network`. Network staffs a roster
(a read), upload publishes an artifact (a write that is hard to take back);
merging them would let "find me an agent" end in an accidental publish.

## 1. Ask the destination first — always