okstra 0.80.0 → 0.81.0

package/README.kr.md

@@ -1,6 +1,6 @@
 # okstra
 
-> npm: [`okstra`](https://www.npmjs.com/package/okstra) · 설치: `npx -y okstra@latest install --runtime claude-code`
+> npm: [`okstra`](https://www.npmjs.com/package/okstra) · 설치: `npx -y okstra@latest install`
 >
 > English: [`README.md`](README.md)
 
@@ -74,12 +74,14 @@ okstra/                          npm 패키지 = repo 루트
 ├── archive/                     완료된 run
 └── .locks/                      central/task mutex 파일
 
-~/.claude/skills/                Claude Code 가 자동 인식
-└── okstra-*/SKILL.md            스킬 11종 (§3.3 참조)
+~/.claude/skills/                Claude Code 가 자동 인식 (`~/.claude` 가 있을 때)
+~/.codex/skills/                 Codex 호환 host 가 인식 (`~/.codex` 가 있을 때)
+~/.omp/agent/skills/             둘 다 없을 때 OMP-native fallback skill target
+└── okstra-*/SKILL.md            사용자 노출 스킬 + hidden 내부 지원 스킬
 
-~/.claude/agents/                Claude Code 가 자동 인식 (subagent 디스커버리 경로)
+~/.claude/agents/                Claude Code 가 자동 인식 (`~/.claude` 가 있을 때)
 └── {claude,codex,gemini,report-writer}-worker.md   worker subagent 정의
-                                 (multi-agent dispatch 필수)
+                                 (Claude Code multi-agent dispatch 필수)
 
 <프로젝트 루트>/.okstra/
 ├── project.json                 {projectId, projectRoot, ...} (`/okstra-setup` 이 작성)
@@ -95,8 +97,8 @@ okstra/                          npm 패키지 = repo 루트
 |---|---|---|
 | 런타임 코드 (python + bash) | `~/.okstra/{lib/python, bin}` | `okstra install` |
 | agents/prompts/schemas/templates/validators | npm 패키지의 `runtime/` | `okstra` 패키지 자체 (`okstra paths` 로 해석) |
-| 스킬 마크다운 | `~/.claude/skills/<name>/SKILL.md` | `okstra install` (`installed-skills.json` 에 트래킹) |
-| 워커 에이전트 마크다운 | `~/.claude/agents/<worker>.md` | `okstra install` (`installed-agents.json` 에 트래킹) |
+| 스킬 마크다운 | `~/.claude/skills`, `~/.codex/skills`, 또는 `~/.omp/agent/skills` | `okstra install` (`installed-skills.json` 에 target별 트래킹) |
+| 워커 에이전트 마크다운 | `~/.claude/agents/<worker>.md` | `~/.claude` 가 있을 때 `okstra install` (`installed-agents.json` 에 트래킹) |
 | 프로젝트 메타데이터 | `<project>/.okstra/` | `/okstra-setup` + 프로젝트 자체 |
 | Run 인덱스 | `~/.okstra/{recent,active}.jsonl` | `prepare_task_bundle` |
 
@@ -105,10 +107,10 @@ okstra/                          npm 패키지 = repo 루트
 ### 3.1 최초 셋업 (머신당 1회)
 
 ```bash
-npx -y okstra@latest install --runtime claude-code
+npx -y okstra@latest install
 ```
 
-`~/.okstra/{lib/python, bin, templates, version}`, `~/.claude/skills/` 아래 스킬 마크다운 11개, `~/.claude/agents/` 아래 worker agent 4개, `~/.okstra/` 의 설치 asset manifest 를 생성합니다. 재실행은 idempotent — 파일별 hash 를 비교하고 바뀐 파일만 갱신합니다.
+`~/.okstra/{lib/python, bin, templates, version}` 과 `~/.okstra/` 의 설치 asset manifest 를 생성합니다. 스킬 설치는 host home 기준입니다. `~/.claude` 가 있으면 `~/.claude/skills/` 와 `~/.claude/agents/` 에 설치하고, `~/.codex` 가 있으면 `~/.codex/skills/` 에도 설치합니다. 둘 다 없고 `~/.omp/agent` 가 있으면 `~/.omp/agent/skills/` 에 설치합니다. 사용자 진입점 스킬만 목록에 보이고, lead/support 내부 스킬은 hidden 으로 설치되어 런타임이 해석할 수만 있게 둡니다. 재실행은 idempotent — 파일별 hash 를 비교하고 바뀐 파일만 갱신합니다.
 
 검증:
 
@@ -125,10 +127,10 @@ npx -y okstra@latest doctor
 ```bash
 npm i -g okstra
 okstra --version       # CLI 가 PATH 에 잡혔는지 확인
-okstra install --runtime claude-code   # 'npx -y okstra@latest install --runtime claude-code' 와 동일
+okstra install          # 'npx -y okstra@latest install' 과 동일
 ```
 
-글로벌 설치는 Node CLI 를 PATH 에 등록할 뿐입니다. 런타임(`~/.okstra/`) 과 Claude 스킬(`~/.claude/skills/`) 은 여전히 `okstra install` 이 생성합니다 — `npm i -g` 에 포함되지 않습니다. 실험적 Codex lead adapter 용 공유 runtime 만 설치하려면 `okstra install --runtime codex` 를 사용하세요 (`~/.claude` 자산은 건너뜀). 이후 업그레이드: `npm i -g okstra@latest && okstra install`. 글로벌 바이너리 제거: `npm uninstall -g okstra` (`~/.okstra/` 는 그대로; 그것까지 지우려면 `okstra uninstall`).
+글로벌 설치는 Node CLI 를 PATH 에 등록할 뿐입니다. 런타임(`~/.okstra/`) 과 host skill directory(`~/.claude/skills/`, `~/.codex/skills/`, 또는 `~/.omp/agent/skills/`) 는 여전히 `okstra install` 이 생성합니다 — `npm i -g` 에 포함되지 않습니다. 이후 업그레이드: `npm i -g okstra@latest && okstra install`. 글로벌 바이너리 제거: `npm uninstall -g okstra` (`~/.okstra/` 는 그대로; 그것까지 지우려면 `okstra uninstall`).
 
 **글로벌 설치 시 스킬 동작.** 모든 okstra 스킬은 PATH 에 잡힌 `okstra` 를 자동 감지하여 `npx -y okstra@latest` 대신 우선 사용합니다. 즉 글로벌 설치를 해두면 매 스킬 호출(`okstra-run`, `okstra-inspect`, `okstra-schedule`, `okstra-setup` Step 2 의 Step 0) 마다 npx 가 패키지 fetch / 버전 체크하던 비용이 사라집니다. 스킬이 본인이 설치한 버전을 그대로 쓰므로 **업그레이드 타이밍은 사용자가 통제** 합니다 — 더 이상 호출마다 `@latest` 가 강제되지 않습니다. 새 릴리스를 받으려면 원하는 시점에 `npm i -g okstra@latest && okstra install` 을 실행하세요. `okstra` 가 PATH 에 없으면 스킬은 자동으로 npx fallback 으로 동작하므로 글로벌 설치가 없는 환경에서도 변경 없이 그대로 동작합니다.
 

package/README.md

@@ -1,6 +1,6 @@
 # okstra
 
-> npm: [`okstra`](https://www.npmjs.com/package/okstra) · install: `npx -y okstra@latest install --runtime claude-code`
+> npm: [`okstra`](https://www.npmjs.com/package/okstra) · install: `npx -y okstra@latest install`
 >
 > 한국어 매뉴얼: [`README.kr.md`](README.kr.md)
 
@@ -73,12 +73,14 @@ okstra/                          npm package = repo root
 ├── archive/                     completed runs
 └── .locks/                      central/task mutex files
 
-~/.claude/skills/                discovered automatically by Claude Code
-└── okstra-*/SKILL.md            11 skills total (see §3.3)
+~/.claude/skills/                discovered automatically by Claude Code (if ~/.claude exists)
+~/.codex/skills/                 discovered by Codex-compatible hosts (if ~/.codex exists)
+~/.omp/agent/skills/             fallback OMP-native skill target when neither exists
+└── okstra-*/SKILL.md            visible user skills + hidden internal support skills
 
-~/.claude/agents/                discovered automatically by Claude Code
+~/.claude/agents/                discovered automatically by Claude Code (if ~/.claude exists)
 └── {claude,codex,gemini,report-writer}-worker.md   subagent definitions
-                                 (required for multi-agent dispatch)
+                                 (required for Claude Code multi-agent dispatch)
 
 <project-root>/.okstra/
 ├── project.json                 {projectId, projectRoot, ...} (written by /okstra-setup)
@@ -94,8 +96,8 @@ okstra/                          npm package = repo root
 |---|---|---|
 | Runtime code (python + bash) | `~/.okstra/{lib/python, bin}` | `okstra install` |
 | agents/prompts/schemas/templates/validators | npm package's `runtime/` | the `okstra` package (resolved via `okstra paths`) |
-| Skill markdown | `~/.claude/skills/<name>/SKILL.md` | `okstra install` (tracked in `installed-skills.json`) |
-| Worker agent markdown | `~/.claude/agents/<worker>.md` | `okstra install` (tracked in `installed-agents.json`) |
+| Skill markdown | `~/.claude/skills`, `~/.codex/skills`, or `~/.omp/agent/skills` | `okstra install` (tracked per target in `installed-skills.json`) |
+| Worker agent markdown | `~/.claude/agents/<worker>.md` | `okstra install` when `~/.claude` exists (tracked in `installed-agents.json`) |
 | Project metadata | `<project>/.okstra/` | `/okstra-setup` + the project itself |
 | Run index | `~/.okstra/{recent,active}.jsonl` | `prepare_task_bundle` |
 
@@ -104,10 +106,10 @@ okstra/                          npm package = repo root
 ### 3.1 First-time setup (once per machine)
 
 ```bash
-npx -y okstra@latest install --runtime claude-code
+npx -y okstra@latest install
 ```
 
-Provisions `~/.okstra/{lib/python, bin, templates, version}`, the 11 skill markdown files under `~/.claude/skills/`, the 4 worker agents under `~/.claude/agents/`, and the installed-asset manifests in `~/.okstra/`. Re-running is idempotent — per-file hashes are compared and only changed files are touched.
+Provisions `~/.okstra/{lib/python, bin, templates, version}` and the installed-asset manifests in `~/.okstra/`. Skill installation is host-home driven: if `~/.claude` exists, okstra copies skills to `~/.claude/skills/` and worker agents to `~/.claude/agents/`; if `~/.codex` exists, it also copies skills to `~/.codex/skills/`; if neither exists and `~/.omp/agent` exists, it copies skills to `~/.omp/agent/skills/`. User-facing skills are visible; internal lead/support skills are installed hidden so the runtime can resolve them without cluttering the list. Re-running is idempotent — per-file hashes are compared and only changed files are touched.
 
 Verify:
 
@@ -124,10 +126,10 @@ Every example in this README uses `npx -y okstra@latest <cmd>` so you don't need
 ```bash
 npm i -g okstra
 okstra --version       # confirm the CLI is on PATH
-okstra install --runtime claude-code   # same as 'npx -y okstra@latest install --runtime claude-code'
+okstra install          # same as 'npx -y okstra@latest install'
 ```
 
-The global install only registers the Node CLI on your PATH. The runtime (`~/.okstra/`) and the Claude skills (`~/.claude/skills/`) are still provisioned by `okstra install` — they are not part of `npm i -g`. To install only the shared runtime for the experimental Codex lead adapter, use `okstra install --runtime codex` (skips `~/.claude` assets). To upgrade later: `npm i -g okstra@latest && okstra install`. To remove the global binary: `npm uninstall -g okstra` (leaves `~/.okstra/` untouched; remove that with `okstra uninstall`).
+The global install only registers the Node CLI on your PATH. The runtime (`~/.okstra/`) and host skill directories (`~/.claude/skills/`, `~/.codex/skills/`, or `~/.omp/agent/skills/`) are still provisioned by `okstra install` — they are not part of `npm i -g`. To upgrade later: `npm i -g okstra@latest && okstra install`. To remove the global binary: `npm uninstall -g okstra` (leaves `~/.okstra/` untouched; remove that with `okstra uninstall`).
 
 **Skill behaviour with a global install.** All okstra skills auto-detect a PATH-resolved `okstra` and prefer it over `npx -y okstra@latest`. That means a global install removes the per-call npx fetch / version-check from every skill invocation (Step 0 of `okstra-run`, `okstra-inspect`, `okstra-schedule`, `okstra-setup` Step 2). Since the skill uses your globally installed version directly, *you* control upgrade timing — `@latest` is no longer forced on each call. Run `npm i -g okstra@latest && okstra install` whenever you want to pull a new release. If `okstra` is not on PATH the skill silently falls back to npx, so machines without a global install keep working unchanged.
 

package/docs/kr/architecture.md

@@ -18,7 +18,7 @@
 - **Single python authority**: 모든 prepare wiring(profile/workers/model 해소, path 계산, render, central record_start)이 [`okstra_ctl.run.prepare_task_bundle()`](../../scripts/okstra_ctl/run.py) 한 함수에 모여 있습니다. `okstra.sh` 와 `okstra-run` skill 은 같은 함수를 호출하는 thin caller 이며, 환경 변수로 상태를 전달하지 않습니다 — task 정체성·경로·workflow 상태는 모두 디스크 권위 파일에서 매번 계산됩니다.
 - **Claude handoff (두 모드)**: (a) `okstra.sh` 가 새 `claude` 프로세스를 띄우는 전통 방식, (b) `okstra-run` skill 이 현재 claude 세션 안에서 prepare 후 lead 역할을 그대로 인계받는 in-session 모드. 둘 다 `prepare_task_bundle` 의 산출물(instruction-set 등)을 그대로 사용합니다.
 - **Required team contract**: 각 phase profile의 `Required workers:` 블록이 roster의 권위입니다. 일반 분석 phase는 Claude/Codex analyser + report-writer를 기본으로 하고, Gemini는 profile과 `--workers`가 허용할 때만 포함됩니다. `release-handoff`처럼 lead-only에 가까운 phase는 별도 roster를 가집니다.
-- **User-home install + project-local task bundles**: `npx okstra@latest install --runtime claude-code` 한 명령이 런타임(`~/.okstra/{lib/python, bin, templates}`), 스킬 11종(`~/.claude/skills/<name>/SKILL.md`), worker agent 4종(`~/.claude/agents/*-worker.md`)을 설치합니다. `--runtime codex` 는 실험적 Codex lead adapter 용 공유 runtime 만 설치하고 `~/.claude` 자산을 건너뜁니다. 전역 대화 메모리는 프로젝트와 분리된 `~/.okstra/memory-book/` 에 저장됩니다. 대상 프로젝트에는 task bundle 과 discovery metadata 가 `.okstra/` 아래 저장되고, **추가로 `<PROJECT_ROOT>/.claude/settings.local.json` 이 `~/.okstra/templates/settings.local.json` 을 가리키는 symlink 로 provisioning** 됩니다 (`okstra setup` 또는 `okstra-ctl` prepare 가 idempotent 하게 관리; 기존에 일반 파일이 있었다면 `.bak.<timestamp>` 로 백업 후 교체). 이 symlink 가 host Claude Code 세션에 자동 로드되어 codex/gemini worker wrapper 호출 권한을 부여하므로, 사용자의 글로벌 `~/.claude/settings.json` 은 건드리지 않습니다. 개발용 `okstra install --link <repo>` 는 설치 파일을 repo source로 symlink합니다.
+- **User-home install + project-local task bundles**: `npx okstra@latest install` 한 명령이 런타임(`~/.okstra/{lib/python, bin, templates}`)을 설치하고, 존재하는 agent home 에 skill 을 복사합니다. `~/.claude` 가 있으면 Claude skills + worker agent 4종(`~/.claude/agents/*-worker.md`), `~/.codex` 가 있으면 Codex skills, 둘 다 없고 `~/.omp/agent` 가 있으면 OMP-native skills 를 설치합니다. 사용자 진입점 스킬만 목록에 노출되고 lead/support 내부 스킬은 `hide: true` 로 설치됩니다. 전역 대화 메모리는 프로젝트와 분리된 `~/.okstra/memory-book/` 에 저장됩니다. 대상 프로젝트에는 task bundle 과 discovery metadata 가 `.okstra/` 아래 저장되고, **추가로 `<PROJECT_ROOT>/.claude/settings.local.json` 이 `~/.okstra/templates/settings.local.json` 을 가리키는 symlink 로 provisioning** 됩니다 (`okstra setup` 또는 `okstra-ctl` prepare 가 idempotent 하게 관리; 기존에 일반 파일이 있었다면 `.bak.<timestamp>` 로 백업 후 교체). 이 symlink 가 host Claude Code 세션에 자동 로드되어 codex/gemini worker wrapper 실행 권한을 제공합니다.
 - **Resume and clarification**: `--task-key`, `--resume-clarification`, `--clarification-response`로 같은 task 재개와 lead의 추가 질문 응답 흐름을 지원합니다.
 - **Derived views and telemetry**: final-report data.json → Markdown → slim MD / self-contained HTML view, worker error sidecar, wrapper log sidecar, token usage / cost accounting을 제공합니다.
 
@@ -152,9 +152,9 @@ okstra 의 prepare 책임은 단일 python 진입점 [`okstra_ctl.run.prepare_ta
 - [`agents/SKILL.md`](../../agents/SKILL.md) — main okstra lead contract.
 - [`skills/okstra-setup/SKILL.md`](../../skills/okstra-setup/SKILL.md) — **첫 실행 부트스트랩**. `okstra install` + `project.json` 생성.
 - [`skills/okstra-run/SKILL.md`](../../skills/okstra-run/SKILL.md) — **현재 claude 세션 안에서 okstra task 를 시작**하는 in-session 진입점. `prepare_task_bundle` 직접 호출.
-- `skills/okstra-{brief,run,memory,inspect,schedule,context-loader,team-contract,convergence,report-writer,coding-preflight}/SKILL.md` — brief 작성, phase 진행, 전역 Memory Book 저장/검색, status/history/report/time/log/cost read-side, schedule 보조 skill, 구현/검증 워커의 언어별 coding preflight. `okstra-inspect logs` 는 codex/gemini wrapper 가 매 dispatch 마다 `runs/<task-type>/prompts/<worker>-prompt-<phase>-<seq>.log` 로 남기는 live-log sidecar 의 인벤토리·정리 안내 (read-only, find-delete cleanup 명령 제안만 함). `okstra-inspect cost` 는 `okstra context-cost` CLI 결과를 요약해 task bundle 의 lead/worker/report-writer 읽기 비용을 보여준다.
-- 플러그인 매니페스트: [`../../.claude-plugin/plugin.json`](../../.claude-plugin/plugin.json) — `npx skills@latest add Devonshin/okstra` 보조 채널이 참조. 일반 셋업에는 `npx okstra@latest install` 을 사용한다.
-- 설치 위치: `~/.claude/skills/<name>/SKILL.md` (`okstra-install.sh` dev 설치, 또는 위 npx 채널).
+- `skills/okstra-{brief,run,memory,inspect,schedule,context-loader,team-contract,convergence,report-writer,coding-preflight}/SKILL.md` — brief 작성, phase 진행, 전역 Memory Book 저장/검색, status/history/report/time/log/cost read-side, schedule 보조 skill, 구현/검증 워커의 언어별 coding preflight. `context-loader` / `team-contract` / `convergence` / `report-writer` / `coding-preflight` 와 `agents/SKILL.md` lead skill 은 내부 지원 스킬이며 frontmatter `hide: true` 로 설치되어 목록에는 노출되지 않습니다. `okstra-inspect logs` 는 codex/gemini wrapper 가 매 dispatch 마다 `runs/<task-type>/prompts/<worker>-prompt-<phase>-<seq>.log` 로 남기는 live-log sidecar 의 인벤토리·정리 안내 (read-only, find-delete cleanup 명령 제안만 함). `okstra-inspect cost` 는 `okstra context-cost` CLI 결과를 요약해 task bundle 의 lead/worker/report-writer 읽기 비용을 보여준다.
+- 플러그인 매니페스트: [`../../.claude-plugin/plugin.json`](../../.claude-plugin/plugin.json) — `npx skills@latest add Devonshin/okstra` 보조 채널이 참조. 일반 셋업에는 `npx okstra@latest install` 을 사용한다. 플러그인 매니페스트는 사용자 진입점 6개(`okstra-setup`, `okstra-brief`, `okstra-run`, `okstra-memory`, `okstra-inspect`, `okstra-schedule`)만 노출한다.
+- 설치 위치: `~/.claude/skills/<name>/SKILL.md`, `~/.codex/skills/<name>/SKILL.md`, 또는 fallback `~/.omp/agent/skills/<name>/SKILL.md`.
 - 릴리스 절차: [`../../RELEASING.md`](../../RELEASING.md) — npm publish 흐름과 release-please / manual fallback.
 
 ## Architecture: python authority + thin callers
@@ -533,7 +533,7 @@ scripts/okstra.sh workflow가 사용하는 project-local Claude assets는 아래
 - `.okstra/discovery/latest-task.json`: 현재 프로젝트에서 가장 최근에 준비된 okstra task bundle을 가리키는 current-task convenience pointer
 - `.okstra/discovery/task-catalog.json`: 현재 프로젝트에 준비된 okstra task bundle 목록을 `taskKey`, `taskGroup`, `taskId` 기준으로 유지하는 canonical project-level catalog
 - `instruction-set/reference-expectations.md`: 현재 task가 참조해야 할 config files, deployment manifests, expected values를 task-level canonical artifact로 정리한 파일
-- `~/.claude/skills/okstra-*/...`, `~/.claude/agents/...`: `okstra install` 이 사용자 홈에 seed하는 Claude asset (project-local 시딩은 더 이상 발생하지 않음 — `okstra install --refresh` 로 갱신)
+- `~/.claude/skills/okstra-*/...`, `~/.codex/skills/okstra-*/...`, `~/.omp/agent/skills/okstra-*/...`, `~/.claude/agents/...`: `okstra install` 이 사용자 홈에 seed하는 skill/agent asset (project-local 시딩은 더 이상 발생하지 않음 — `okstra install --refresh` 로 갱신)
 
 이전의 아래 파일들은 더 이상 okstra 생성 대상이 아닙니다.
 
@@ -1001,8 +1001,8 @@ phase 산출물의 출고 가능 여부를 강제하는 진입점:
 - Executor 별 worktree cwd 주입: codex / gemini executor 는 wrapper(`okstra-codex-exec.sh -C` / `okstra-gemini-exec.sh --include-directories`) 가 CLI layer 에서 cwd 를 worktree 로 고정합니다. Claude executor 는 Bash tool 에 per-call cwd 인자가 없어 cwd 민감 toolchain (`cargo`/`npm`/`pnpm`/`bun`/`pytest`/`make`/`go`) 호출을 같은 Bash invocation 안에서 `cd {{EXECUTOR_WORKTREE_PATH}} && <cmd>` 로 prefix 합니다 — `bash -lc`/`bash -c` 래핑은 금지되며 (`cd` leading token 이 가려져 permission auto-allow 우회 실패), 작업 디렉터리 플래그 (`git -C`, `cargo --manifest-path` 등) 가 있으면 그것을 우선합니다. 자세한 규약은 `prompts/profiles/implementation.md` 의 *Executor Worktree* 블록과 `agents/workers/claude-worker.md` 의 Executor exception 항목 참고.
 - project-level current-task convenience pointer는 `.okstra/discovery/latest-task.json`입니다.
 - project-level canonical task inventory는 `.okstra/discovery/task-catalog.json`입니다.
-- okstra Claude asset은 `~/.claude/skills/`와 `~/.claude/agents/` 아래에 `okstra install` 시점에 seed되며, `okstra install --refresh` 로 갱신할 수 있습니다 (per-project seeding은 더 이상 수행되지 않음).
-- seeded okstra Claude assets는 Agent Teams 우선, sequential/background fallback 차선 규칙을 Claude에게 제공합니다.
+- okstra skill asset은 `okstra install` 시점에 존재하는 agent home 기준으로 seed됩니다: `~/.claude/skills/` + `~/.claude/agents/`, `~/.codex/skills/`, 또는 fallback `~/.omp/agent/skills/` (per-project seeding은 더 이상 수행되지 않음).
+- seeded okstra Claude assets는 Agent Teams 우선, sequential/background fallback 차선 규칙을 Claude에게 제공합니다. Codex/OMP targets 는 skill markdown 만 받습니다.
 - 최종 판단은 스크립트가 아니라 Claude가 수행합니다.
 - stable task key를 유지해야 이후 bug 추적, 재수정, 재검증이 가능합니다.
 - 워커 에러는 옵션 sidecar `runs/<task-type>/logs/errors-<task-type>-<seq>.jsonl`로 수집되며 lead가 단독 writer입니다. 진입점 helper는 `scripts/okstra-error-log.py`입니다.

package/docs/kr/cli.md

@@ -318,7 +318,7 @@ Lead runtime independence boundary:
 - `codex`: Codex lead adapter 용 runtime marker 입니다. `okstra codex-run` 이 `--render-only --lead-runtime codex` 를 소유해 task bundle 을 준비하고, 준비된 run manifest 는 `okstra codex-dispatch` 로 CLI-backed worker 실행에 넘길 수 있습니다.
 - `external`: Claude Code Teams 없이 `--render-only --lead-runtime external` 로 task bundle 과 external lead prompt 를 준비하고, lead 는 `okstra team dispatch` / `okstra team await` / `okstra team teardown` 으로 tmux-pane worker lifecycle 을 관리합니다. 이 path 는 `TeamCreate` / `Agent(...)` 를 쓰지 않고 artifact-only accounting 을 사용합니다.
 
-현재 Claude Code 독립 범위는 external lead prompt + `okstra team *` worker dispatch 입니다. non-render `okstra_ctl.run --lead-runtime external` remains blocked; 완전한 external lead driver 는 아직 별도 구현 대상입니다. `--runtime external` does not install `~/.claude` assets, but selecting a `claude` worker still requires a local Claude CLI wrapper.
+현재 Claude Code 독립 범위는 external lead prompt + `okstra team *` worker dispatch 입니다. non-render `okstra_ctl.run --lead-runtime external` remains blocked; 완전한 external lead driver 는 아직 별도 구현 대상입니다. `--runtime external` 은 runtime adapter 선택만 의미하며, 스킬 설치 여부는 `~/.claude` / `~/.codex` / `~/.omp/agent` home 존재 여부가 결정합니다. `claude` worker 선택은 여전히 local Claude CLI wrapper 를 필요로 합니다.
 
 ### Runtime auto-detection (`auto`)
 
@@ -328,9 +328,9 @@ Lead runtime independence boundary:
 - Codex host: `okstra run` 이 `codex-run` -> `codex-dispatch` 를 orchestration 합니다.
 - generic terminal + tmux: `okstra run` 이 `render-bundle --lead-runtime external` -> `okstra team dispatch` -> `okstra team await` 를 orchestration 합니다.
 
-`okstra install` / `ensure-installed` / `doctor` / `render-bundle` 도 `auto` 를 기본값으로 받지만, host signal 이 없는 plain terminal 에서는 host 지정이 필요합니다. 그래서 Claude Code skill 들은 `--runtime claude-code` / `--lead-runtime claude-code` 를 명시합니다.
+`okstra install` / `ensure-installed` / `doctor` / `render-bundle` 도 `auto` 를 기본값으로 받지만, host signal 이 없는 plain terminal 에서는 host 지정이 필요합니다. 그래서 Claude Code skill 들은 `--runtime claude-code` / `--lead-runtime claude-code` 를 명시합니다. 단, `okstra install` 의 스킬 복사 대상은 runtime resolution 이 아니라 agent home 존재 여부입니다. `~/.claude` 와 `~/.codex` 가 있으면 둘 다 설치하고, 둘 다 없을 때만 `~/.omp/agent` 를 fallback 으로 사용합니다.
 
-`installed-runtimes.json` 은 schemaVersion 2 로 `installRequest`, `runtimeResolution`, `installedRuntimes`, `installedAssets` 를 분리합니다. 이전 `codexAdapter` / `externalAdapter` 는 v1 manifest read 호환 경로에서만 해석됩니다.
+`installed-runtimes.json` 은 schemaVersion 2 로 `installRequest`, `runtimeResolution`, `installedRuntimes`, `installedAssets` 를 분리합니다. `installed-skills.json` 은 schemaVersion 2 target 목록(`provider`, `root`, `skills`)으로 Claude/Codex/OMP skill target 을 기록하며, uninstall 은 이 target 목록을 기준으로 제거합니다. 이전 `codexAdapter` / `externalAdapter` 는 v1 manifest read 호환 경로에서만 해석됩니다.
 
 Codex lead dry-run 은 `okstra codex-run <args...>` 를 쓰면 됩니다. 이 명령은 `--render-only --lead-runtime codex` 를 직접 붙이고, worker dispatch 없이 준비된 task bundle 과 lead prompt 를 출력합니다.
 생성된 team-state / run-manifest / task-manifest 는 `leadEventsPath` 로 `runs/<task-type>/state/lead-events-<task-type>-<seq>.jsonl` 를 가리키며, render 단계는 `bundle-prepared` event 를 기록합니다.
@@ -623,9 +623,9 @@ chmod +x ~/.local/bin/okstra-ctl
 | 명령 | 용도 |
 |---|---|
 | `okstra paths [--field <name>\|--shell]` | package/runtime/home/bin/pythonpath/version 경로 출력 |
-| `okstra install [--runtime claude-code\|codex\|external\|all] [--refresh\|--dry-run\|--link <repo>]` | runtime, templates, skills, agents 설치/갱신. 기본값 `claude-code` 는 기존처럼 Claude skills/agents 까지 설치한다. `codex` / `external` 은 공유 runtime 만 설치하고 `~/.claude` 자산을 건드리지 않는다 |
-| `okstra ensure-installed [--runtime claude-code\|codex\|external\|all] [-q]` | 설치 상태 확인, stale이면 같은 runtime 으로 재설치. `codex` / `external` runtime 은 Claude skills/agents drift 검사를 건너뛴다 |
-| `okstra uninstall [--purge -y]` | 설치 자산 제거. 기본값은 사용자 데이터 보존 |
+| `okstra install [--runtime claude-code\|codex\|external\|all] [--refresh\|--dry-run\|--link <repo>]` | runtime, templates, skills, agents 설치/갱신. 기본 runtime 은 `auto`; 스킬 대상은 runtime 이 아니라 기존 home 기준이다. `~/.claude` 가 있으면 Claude skills + agents, `~/.codex` 가 있으면 Codex skills, 둘 다 없고 `~/.omp/agent` 가 있으면 OMP skills 를 설치한다 |
+| `okstra ensure-installed [--runtime claude-code\|codex\|external\|all] [-q]` | 설치 상태 확인, stale이면 같은 runtime 으로 재설치. 존재하는 skill target 의 drift 만 검사한다 |
+| `okstra uninstall [--purge -y]` | 설치 자산 제거. 기본값은 `installed-skills.json` target 목록과 `installed-agents.json` 기준으로 제거하고 사용자 데이터는 보존 |
 | `okstra doctor [--runtime claude-code\|codex\|external\|all] [--phase <phase>] [--json]` | runtime + Python import + skill/agent 설치 진단. `codex` / `external` runtime 은 Claude skill checks 를 제외한다. `--phase` 는 `implementation`, `final-verification`, `release-handoff`, `improvement-discovery` 실행 전 readiness 체크를 추가한다 |
 | `okstra setup --project-id <id>` | 현재 프로젝트의 `.okstra/project.json` 생성/갱신 |
 | `okstra check-project [--json]` | 현재 프로젝트가 등록되었는지 검증 |

package/docs/project-structure-overview.md

@@ -124,14 +124,14 @@ Runtime/install asset changes follow this checklist:
 - `runtime/python/*` → `~/.okstra/lib/python/`
 - `runtime/bin/*` → `~/.okstra/bin/`
 - `runtime/templates/*` → `~/.okstra/templates/`
-- `runtime/skills/<name>` → `~/.claude/skills/<name>`
-- `runtime/agents/workers/*.md` → `~/.claude/agents/*-worker.md`
-- install manifests → `~/.okstra/installed-skills.json`, `~/.okstra/installed-agents.json`
+- `runtime/skills/<name>` + `runtime/agents/SKILL.md` → existing skill homes: `~/.claude/skills`, `~/.codex/skills`, or fallback `~/.omp/agent/skills`
+- `runtime/agents/workers/*.md` → `~/.claude/agents/*-worker.md` when `~/.claude` exists
+- install manifests → `~/.okstra/installed-skills.json` (target-aware), `~/.okstra/installed-agents.json`
 - version stamp → `~/.okstra/version`
 
 `--link <repo>` mode is for development and symlinks installed files back to repo sources.
 
-`src/runtime-resolver.mjs` is the single reference point for runtime auto-detection. `okstra install` defaults to `--runtime auto`, records the request and resolution in `installed-runtimes.json` schemaVersion 2, and still copies the shared runtime payload from the installed package `runtime/` tree. Dynamic capabilities such as `tmux` and `codex` CLI availability are checked by `doctor` and `run`, not frozen into the install manifest. Claude Code skills pass explicit `--runtime claude-code` / `--lead-runtime claude-code` so they never depend on host auto-detection.
+`src/runtime-resolver.mjs` is the single reference point for runtime auto-detection. `okstra install` defaults to `--runtime auto`, records the request and resolution in `installed-runtimes.json` schemaVersion 2, and still copies the shared runtime payload from the installed package `runtime/` tree. Skill targets are discovered from existing agent homes: `~/.claude` and `~/.codex` are both populated when present; `~/.omp/agent` is the fallback only when neither exists. Dynamic capabilities such as `tmux` and `codex` CLI availability are checked by `doctor` and `run`, not frozen into the install manifest. Claude Code skills pass explicit `--runtime claude-code` / `--lead-runtime claude-code` so they never depend on host auto-detection.
 
 ---
 
@@ -392,7 +392,7 @@ Project-local `<PROJECT_ROOT>/.claude/settings.local.json` is provisioned as a s
 
 ### 7.1 First setup
 
-1. `okstra install --runtime claude-code`
+1. `okstra install`
 2. `okstra doctor --runtime claude-code`
 3. inside target repo: `okstra setup --project-id <id>` or `/okstra-setup`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.80.0",
+  "version": "0.81.0",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.80.0",
-  "builtAt": "2026-06-14T13:33:02.891Z",
+  "package": "0.81.0",
+  "builtAt": "2026-06-14T17:44:49.025Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: okstra
 description: Use when the user says "okstra", "cross verify", "cross-check with other AIs", "compare Claude, Codex, and Gemini", or asks for multi-agent comparison against a prepared task bundle.
+hide: true
 ---
 
 # OKSTRA Skill

package/runtime/skills/okstra-brief/SKILL.md

@@ -121,15 +121,9 @@ okstra check-project --json
 Parse the JSON from stdout:
 
 - `ok: true` → use `projectRoot` from the JSON output. Carry it as a literal string into the steps below.
-- `ok: false` → ask the user with a **plain text prompt** for an absolute project-root path, then rerun as a separate tool call with the literal absolute path (no `$(pwd)`, no shell variables):
+- `ok: false` → tell the user: "this project has no okstra setup. Run `/okstra-setup` first." Then stop.
 
-  ```bash
-  okstra check-project --cwd /abs/path/from/user --json
-  ```
-
-  If still `ok: false`, tell the user to run `okstra-setup` and stop.
-
-> If the `okstra` binary is not on `PATH` at all, the command above will not run. In that case tell the user verbatim: "okstra not installed — run `npx okstra@latest install` once, then retry this skill." Do **not** try to invoke `npx -y okstra@latest ...` from this skill — `npx` is not on the literal-token allow-list this skill targets and will force a confirmation prompt on every subsequent call.
+> If the `okstra` binary is not on `PATH` at all, the command above will not run. In that case tell the user verbatim: "okstra not installed — run `/okstra-setup` first." Do **not** try to invoke `npx -y okstra@latest ...` from this skill — `npx` is not on the literal-token allow-list this skill targets and will force a confirmation prompt on every subsequent call.
 
 ## Step 1: Choose input source
 

package/runtime/skills/okstra-coding-preflight/SKILL.md

@@ -2,6 +2,7 @@
 name: okstra-coding-preflight
 description: Provides language-specific coding conventions, idioms, and test-writing guidance for Java, Kotlin, JavaScript, TypeScript, Node.js, Python, SQL, and Rust. okstra lead/workers MUST consult this skill before writing, editing, refactoring, or testing code in any of these languages — including any new file, function, or test — even when the task seems simple enough to handle directly. Detect the target language from the file extension, project config (package.json/Cargo.toml/pyproject.toml/pom.xml/build.gradle), or task brief, and apply the matching conventions.
 user-invocable: false
+hide: true
 ---
 
 # okstra Code Preflight

package/runtime/skills/okstra-context-loader/SKILL.md

@@ -2,6 +2,7 @@
 name: okstra-context-loader
 description: Use when okstra Phase 1 starts, or when the user asks for an okstra task bundle path, task-manifest location, or the current/latest okstra run artifacts.
 user-invocable: false
+hide: true
 ---
 
 # OKSTRA Context Loader

package/runtime/skills/okstra-convergence/SKILL.md

@@ -2,6 +2,7 @@
 name: okstra-convergence
 description: Use when okstra Phase 5.5 needs iterative cross-verification between workers, or when worker findings must be classified by consensus level before final synthesis.
 user-invocable: false
+hide: true
 ---
 
 # OKSTRA Convergence

package/runtime/skills/okstra-inspect/SKILL.md

@@ -22,7 +22,7 @@ Single read-side entry point for okstra runtime inspection plus the one write-si
 Before any sub-command, run each of the following commands as a **separate Bash tool call**. Each command starts with the literal token `okstra` so the `Bash(okstra:*)` permission match succeeds. Do **not** wrap any of them in `if`, `eval`, `export`, `$(...)`, `VAR=...`, `||`, or `&&`, and do **not** introduce a `$OKSTRA_CMD` variable or an `npx -y okstra@latest` fallback — those leading tokens defeat the permission match and force a confirmation prompt on every call. The LLM (you) inspects each command's output and decides what to do next in natural language — never in shell.
 
 1. `okstra ensure-installed --runtime claude-code`
-   If this exits non-zero, tell the user: "okstra not installed — run `npx okstra@latest install` once, then retry this skill." Then stop. Do **not** try to invoke `npx -y okstra@latest ...` as a fallback.
+   If this exits non-zero, tell the user: "okstra not installed — run `/okstra-setup` first." Then stop. Do **not** try to invoke `npx -y okstra@latest ...` as a fallback.
 
 2. `okstra check-project --json`
    Reads the project from the current working directory. Parse the JSON from stdout. The shape is `{ok, projectRoot, projectJsonPath, projectId}`.

package/runtime/skills/okstra-report-writer/SKILL.md

@@ -2,6 +2,7 @@
 name: okstra-report-writer
 description: Use when okstra is in Phase 6 or Phase 7 — writing the final synthesis report, persisting artifacts, or updating manifests.
 user-invocable: false
+hide: true
 ---
 
 # OKSTRA Report Writer

package/runtime/skills/okstra-run/SKILL.md

@@ -56,19 +56,17 @@ Never invent additional questions. Never reorder. **Never drop, hide, or merge a
 Run each of the following commands as a **separate Bash tool call**. Each command starts with the literal token `okstra` so the `Bash(okstra:*)` permission match succeeds. Do **not** wrap any of them in `if`, `eval`, `export`, `$(...)`, `VAR=...`, `||`, or `&&` — those leading tokens defeat the permission match and force a confirmation prompt on every call. The LLM (you) inspects each command's JSON output and decides what to do next in natural language — never in shell.
 
 1. `okstra ensure-installed --runtime claude-code`
-   If this exits non-zero, tell the user: "okstra runtime missing — run `npx okstra@latest install` once and retry." Then stop.
+   If this exits non-zero, tell the user: "okstra runtime missing — run `/okstra-setup` first." Then stop. Do **not** try to invoke `npx -y okstra@latest ...` as a fallback.
 
 2. `okstra paths --json`
    Read `pythonPath` and other path fields from the JSON output. **Do not** `export PYTHONPATH=...` from this skill — every subsequent `okstra <subcmd>` call already self-bootstraps its Python path. Keep the parsed values in mind only as diagnostic context.
 
 3. `okstra check-project --json`
-   Reads the project from the current working directory. Parse the JSON from stdout. If `ok` is `false`, ask the user with a **plain text prompt** for an absolute project-root path, then rerun as a separate tool call (still literal-token-first):
-   `okstra check-project --cwd /abs/path/from/user --json`
-   Substitute the literal absolute path the user gave you (no `$(pwd)`, no shell variables). Re-prompt with plain text on continued failure.
+   Reads the project from the current working directory. Parse the JSON from stdout. If `ok` is `false`, tell the user: "this project has no okstra setup. Run `/okstra-setup` first." Then stop.
 
 Parse `projectRoot` and `projectId` from the successful `check-project --json` output and carry them as literal strings into Step 2.
 
-> If the `okstra` binary is not on `PATH` at all, none of the commands above will run. In that case tell the user verbatim: "okstra not installed — run `npx okstra@latest install` once, then retry this skill." Do **not** try to invoke `npx -y okstra@latest ...` from this skill — `npx` is not on the literal-token allow-list and will force a confirmation prompt on every wizard call afterward.
+> If the `okstra` binary is not on `PATH` at all, none of the commands above will run. In that case tell the user verbatim: "okstra not installed — run `/okstra-setup` first." Do **not** try to invoke `npx -y okstra@latest ...` from this skill — `npx` is not on the literal-token allow-list and will force a confirmation prompt on every wizard call afterward.
 
 ## Step 2: Initialize the wizard
 

package/runtime/skills/okstra-schedule/SKILL.md

@@ -40,7 +40,7 @@ If `--title` is omitted, derive a default title from `task-group` (e.g. `uploadF
 Before anything else in this skill, run each of the following commands as a **separate Bash tool call**. Each command starts with the literal token `okstra` so the `Bash(okstra:*)` permission match succeeds. Do **not** wrap any of them in `if`, `eval`, `export`, `$(...)`, `VAR=...`, `||`, or `&&`, and do **not** introduce a `$OKSTRA_CMD` variable or an `npx -y okstra@latest` fallback — those leading tokens defeat the permission match and force a confirmation prompt on every call. The LLM (you) inspects each command's output and decides what to do next in natural language — never in shell.
 
 1. `okstra ensure-installed --runtime claude-code`
-   If this exits non-zero, tell the user: "okstra not installed — run `npx okstra@latest install` once, then retry this skill." Then stop. Do **not** try to invoke `npx -y okstra@latest ...` as a fallback.
+   If this exits non-zero, tell the user: "okstra not installed — run `/okstra-setup` first." Then stop. Do **not** try to invoke `npx -y okstra@latest ...` as a fallback.
 
 2. `okstra check-project --json`
    Reads the project from the current working directory. Parse the JSON from stdout. The shape is `{ok, projectRoot, projectJsonPath, projectId}`.

package/runtime/skills/okstra-team-contract/SKILL.md

@@ -2,6 +2,7 @@
 name: okstra-team-contract
 description: Use when okstra is in Phases 2–5 and needs team operating rules for the Claude lead + worker structure, or when verifying worker roster and model assignments.
 user-invocable: false
+hide: true
 ---
 
 # OKSTRA Team Contract

package/src/cli-registry.mjs

@@ -6,7 +6,7 @@ export const COMMAND_REGISTRY = [
     module: "./install.mjs",
     export: "runInstall",
     category: "admin",
-    summary: ["Install runtime; --runtime codex skips ~/.claude assets"],
+    summary: ["Install runtime; seed skills into existing agent homes"],
   },
   {
     name: "ensure-installed",
@@ -239,7 +239,7 @@ This CLI is the installer/admin tool. Day-to-day usage happens inside a
 Claude Code session via slash commands (/okstra-setup, /okstra-run, ...).
 
 Quick start (CLI):
-  1. npx -y okstra@latest install --runtime claude-code # one-time, this machine
+  1. npx -y okstra@latest install                       # one-time, this machine
   2. cd <your project>
   3. npx -y okstra@latest setup --project-id <id>       # one-time, this project
   4. open a Claude Code session and run /okstra-run     # start a task

package/src/install.mjs

@@ -10,8 +10,14 @@ import { normalizeRuntimeRequest, resolveRuntime } from "./runtime-resolver.mjs"
 
 const SKILLS_MANIFEST_REL = "installed-skills.json";
 const AGENTS_MANIFEST_REL = "installed-agents.json";
-const CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
-const CLAUDE_AGENTS_DIR = join(homedir(), ".claude", "agents");
+const USER_HOME = homedir();
+const CLAUDE_HOME = join(USER_HOME, ".claude");
+const CODEX_HOME = join(USER_HOME, ".codex");
+const OMP_AGENT_HOME = join(USER_HOME, ".omp", "agent");
+const CLAUDE_SKILLS_DIR = join(CLAUDE_HOME, "skills");
+const CODEX_SKILLS_DIR = join(CODEX_HOME, "skills");
+const OMP_SKILLS_DIR = join(OMP_AGENT_HOME, "skills");
+const CLAUDE_AGENTS_DIR = join(CLAUDE_HOME, "agents");
 
 // Source template (relative to runtime root in copy mode, or repo root in link mode).
 const SETTINGS_TEMPLATE_SRC_REL = ["templates", "reports", "settings.template.json"];
@@ -52,10 +58,12 @@ Effect (copy mode):
   ${"$HOME"}/.okstra/bin           <- runtime/bin
   ${"$HOME"}/.okstra/templates     <- runtime/templates  (report.css / report.js / *.template.md)
   ${"$HOME"}/.okstra/templates/settings.local.json <- runtime/templates/reports/settings.template.json
-  ${"$HOME"}/.claude/skills/<name> <- runtime/skills/<name>   (per skill)
-  ${"$HOME"}/.claude/agents/<worker>.md <- runtime/agents/workers/<worker>.md
+  ${"$HOME"}/.claude/skills/<name> <- skills when ${"$HOME"}/.claude exists
+  ${"$HOME"}/.codex/skills/<name>  <- skills when ${"$HOME"}/.codex exists
+  ${"$HOME"}/.omp/agent/skills/<name> <- skills fallback when Claude/Codex homes are absent
+  ${"$HOME"}/.claude/agents/<worker>.md <- worker agents when ${"$HOME"}/.claude exists
   ${"$HOME"}/.okstra/installed-runtimes.json <- manifest of installed runtime adapters
-  ${"$HOME"}/.okstra/installed-skills.json   <- manifest of installed skills
+  ${"$HOME"}/.okstra/installed-skills.json   <- target-aware manifest of installed skills
   ${"$HOME"}/.okstra/installed-agents.json   <- manifest of installed workers
   ${"$HOME"}/.okstra/version       <- installed package version stamp
 
@@ -63,8 +71,10 @@ Effect (link mode):
   ${"$HOME"}/.okstra/lib/python/<pkg> -> <repo>/scripts/<pkg>   (symlink)
   ${"$HOME"}/.okstra/bin/<name>.sh    -> <repo>/scripts/<name>.sh
   ${"$HOME"}/.okstra/templates/settings.local.json -> <repo>/templates/reports/settings.template.json
-  ${"$HOME"}/.claude/skills/<name>    -> <repo>/skills/<name>   (symlink dir)
-  ${"$HOME"}/.claude/agents/<worker>.md -> <repo>/agents/workers/<worker>.md
+  ${"$HOME"}/.claude/skills/<name>    -> <repo>/skills/<name> when ${"$HOME"}/.claude exists
+  ${"$HOME"}/.codex/skills/<name>     -> <repo>/skills/<name> when ${"$HOME"}/.codex exists
+  ${"$HOME"}/.omp/agent/skills/<name> -> <repo>/skills/<name> fallback
+  ${"$HOME"}/.claude/agents/<worker>.md -> <repo>/agents/workers/<worker>.md when ${"$HOME"}/.claude exists
   ${"$HOME"}/.okstra/dev-link         <- <repo> path stamp
   ${"$HOME"}/.okstra/version          <- installed package version stamp
 
@@ -73,10 +83,9 @@ project-local <project>/.claude/settings.local.json that okstra-setup
 provisions, granting per-project Claude Code permissions for okstra
 worker wrapper scripts without modifying the user's global settings.
 
-Worker agent definitions are installed into ${"$HOME"}/.claude/agents/ so
-that Claude Code's subagent discovery picks them up; they cannot live
-inside the package alone because the harness only scans ~/.claude/agents/
-and <project>/.claude/agents/.
+Worker agent definitions are installed into ${"$HOME"}/.claude/agents/ only
+when ${"$HOME"}/.claude exists, so Claude Code's subagent discovery can pick
+them up. Codex/OMP skill targets receive skill markdown only.
 `;
 
 const ENSURE_USAGE = `okstra ensure-installed — idempotent install check
@@ -305,19 +314,22 @@ async function installLinkMode(repoPath, paths, opts) {
     if (!quiet) process.stdout.write(`  bin/${name}: ${action}\n`);
   }
 
-  if (runtimeIncludesClaudeAssets(runtime, opts.resolution)) {
-    const skillResult = await installSkillsLink(repoAbs, { dryRun, quiet });
-    const leadSkillResult = await installLeadSkillLink(repoAbs, { dryRun, quiet });
-    await writeSkillsManifest(paths.home, [...skillResult.installed, ...leadSkillResult], { dryRun });
+  const skillTargets = await detectSkillTargets();
+  const installedSkillTargets = await installSkillTargetsLink(repoAbs, skillTargets, { dryRun, quiet });
+  await writeSkillsManifest(paths.home, installedSkillTargets, { dryRun });
 
-    const agentResult = await installAgentsLink(repoAbs, { dryRun, quiet });
-    await writeAgentsManifest(paths.home, agentResult.installed, { dryRun });
-  } else if (!quiet) {
-    process.stdout.write("  claude assets: skipped for runtime=codex\n");
+  let agentResult = { installed: [] };
+  if (skillTargets.some((target) => target.provider === "claude")) {
+    agentResult = await installAgentsLink(repoAbs, { dryRun, quiet });
   }
+  await writeAgentsManifest(paths.home, agentResult.installed, { dryRun });
 
   await installNamedTemplate(repoAbs, paths, { mode: "link", dryRun, quiet }, SETTINGS_TEMPLATE_DESCRIPTOR);
-  await writeRuntimeManifest(paths.home, runtime, { dryRun, resolution: opts.resolution });
+  await writeRuntimeManifest(paths.home, runtime, {
+    dryRun,
+    resolution: opts.resolution,
+    installedAssets: installedAssetOverrides(installedSkillTargets, agentResult.installed),
+  });
 
   if (!dryRun) {
     await writeFileAtomic(join(paths.home, "dev-link"), repoAbs + "\n", 0o644);
@@ -330,7 +342,7 @@ async function installLinkMode(repoPath, paths, opts) {
     process.stdout.write(
       "\nNext step: register the current project.\n" +
         "  cd <your project> && npx -y okstra@latest setup --project-id <id>\n" +
-        "  (or run /okstra-setup inside a Claude Code session)\n" +
+        "  (or run /okstra-setup inside a Harness Agent session (e.g. claude codex, codex, pi.. ))\n" +
         "\nTip: to use a bare 'okstra' command instead of npx, run:\n" +
         "  npm i -g okstra\n",
     );
@@ -348,15 +360,58 @@ async function listSkillDirs(skillsRoot) {
   }
 }
 
-async function writeSkillsManifest(home, names, opts) {
+async function detectSkillTargets() {
+  const targets = [];
+  const [hasClaude, hasCodex] = await Promise.all([dirExists(CLAUDE_HOME), dirExists(CODEX_HOME)]);
+  if (hasClaude) {
+    targets.push({ provider: "claude", home: CLAUDE_HOME, skillsDir: CLAUDE_SKILLS_DIR });
+  }
+  if (hasCodex) {
+    targets.push({ provider: "codex", home: CODEX_HOME, skillsDir: CODEX_SKILLS_DIR });
+  }
+  if (targets.length === 0 && (await dirExists(OMP_AGENT_HOME))) {
+    targets.push({ provider: "omp", home: OMP_AGENT_HOME, skillsDir: OMP_SKILLS_DIR });
+  }
+  return targets;
+}
+
+function skillTargetManifest(targets) {
+  return targets.map((target) => ({
+    provider: target.provider,
+    root: target.skillsDir,
+    skills: Array.from(new Set(target.installed)).sort(),
+  }));
+}
+
+function installedAssetOverrides(skillTargets, agentNames) {
+  const providers = new Set(skillTargets.map((target) => target.provider));
+  return {
+    claudeSkills: providers.has("claude"),
+    claudeAgents: agentNames.length > 0,
+    codexSkills: providers.has("codex"),
+    ompSkills: providers.has("omp"),
+    skillTargets: Array.from(providers).sort(),
+  };
+}
+
+function installedSkillNames(targets) {
+  return Array.from(new Set(targets.flatMap((target) => target.installed))).sort();
+}
+
+
+async function writeSkillsManifest(home, targets, opts) {
   const { dryRun = false } = opts ?? {};
+  const manifestTargets = skillTargetManifest(targets);
   const data = {
-    version: 1,
+    version: 2,
     installedAt: new Date().toISOString(),
-    skills: Array.from(new Set(names)).sort(),
+    skills: installedSkillNames(targets),
+    targets: manifestTargets,
   };
   if (dryRun) {
-    process.stdout.write(`[dry-run] write skills manifest: ${data.skills.length} entries\n`);
+    process.stdout.write(
+      `[dry-run] write skills manifest: ${data.skills.length} skills across ${data.targets.length} targets\n`,
+    );
     return;
   }
   await writeFileAtomic(
@@ -385,8 +440,13 @@ async function writeAgentsManifest(home, names, opts) {
 }
 
 async function writeRuntimeManifest(home, runtime, opts) {
-  const { dryRun = false, resolution = null } = opts ?? {};
-  const data = buildRuntimeManifest(runtime, new Date().toISOString(), resolution);
+  const { dryRun = false, resolution = null, installedAssets = null } = opts ?? {};
+  const data = buildRuntimeManifest(
+    runtime,
+    new Date().toISOString(),
+    resolution,
+    installedAssets,
+  );
   if (dryRun) {
     process.stdout.write(`[dry-run] write runtime manifest: ${data.installedRuntimes.join(",")}\n`);
     return;
@@ -524,88 +584,100 @@ const SETTINGS_TEMPLATE_DESCRIPTOR = {
   label: "settings template",
 };
 
-async function installSkillsCopy(runtimeRoot, opts) {
+const LEAD_SKILL_NAME = "okstra";
+
+async function installSkillsCopy(runtimeRoot, target, opts) {
   const { refresh, dryRun, quiet } = opts;
   const srcRoot = join(runtimeRoot, "skills");
   const names = await listSkillDirs(srcRoot);
-  if (names.length === 0) {
-    if (!quiet) process.stdout.write("  skills: runtime/skills empty — skipped\n");
-    return { installed: [] };
-  }
   let copied = 0;
   let skipped = 0;
   for (const name of names) {
     const r = await copyTreeIfChanged(
       join(srcRoot, name),
-      join(CLAUDE_SKILLS_DIR, name),
+      join(target.skillsDir, name),
       { refresh, dryRun, mode: 0o644 },
     );
     copied += r.copied;
     skipped += r.skipped;
   }
+  const lead = await installLeadSkillCopy(runtimeRoot, target, opts);
   if (!quiet) {
+    const totalCopied = copied + lead.copied;
+    const totalSkipped = skipped + lead.skipped;
+    const totalSkills = names.length + lead.installed.length;
     process.stdout.write(
-      `  skills: copied=${copied} skipped=${skipped} -> ${CLAUDE_SKILLS_DIR}/ (${names.length} skills)\n`,
+      `  ${target.provider} skills: copied=${totalCopied} skipped=${totalSkipped} -> ${target.skillsDir}/ (${totalSkills} skills)\n`,
     );
   }
-  return { installed: names };
+  return { ...target, installed: [...names, ...lead.installed] };
 }
 
-async function installSkillsLink(repoAbs, opts) {
+async function installSkillsLink(repoAbs, target, opts) {
   const { dryRun, quiet } = opts;
   const srcRoot = join(repoAbs, "skills");
   const names = await listSkillDirs(srcRoot);
-  if (names.length === 0) {
-    if (!quiet) process.stdout.write("  skills: <repo>/skills missing — skipped\n");
-    return { installed: [] };
-  }
-  if (!dryRun) await fs.mkdir(CLAUDE_SKILLS_DIR, { recursive: true });
+  if (!dryRun) await fs.mkdir(target.skillsDir, { recursive: true });
   for (const name of names) {
     const src = join(srcRoot, name);
-    const dst = join(CLAUDE_SKILLS_DIR, name);
+    const dst = join(target.skillsDir, name);
     const action = await ensureSymlink(src, dst, { dryRun });
-    if (!quiet) process.stdout.write(`  skills/${name}: ${action}\n`);
+    if (!quiet) process.stdout.write(`  ${target.provider} skills/${name}: ${action}\n`);
   }
-  return { installed: names };
+  const lead = await installLeadSkillLink(repoAbs, target, opts);
+  return { ...target, installed: [...names, ...lead] };
 }
 
-// The lead `okstra` skill source is agents/SKILL.md (frontmatter `name: okstra`);
-// it doubles as the lead agent contract, so it lives under agents/ rather than
-// skills/. Claude Code only discovers skills at ~/.claude/skills/<name>/SKILL.md,
-// so it must be installed there as its own skill dir — otherwise install ships
-// every okstra-* helper skill but not the lead skill, and edits to agents/SKILL.md
-// never reach the running lead.
-const LEAD_SKILL_NAME = "okstra";
-
-async function installLeadSkillCopy(runtimeRoot, opts) {
+async function installLeadSkillCopy(runtimeRoot, target, opts) {
   const { refresh, dryRun, quiet } = opts;
   const src = join(runtimeRoot, "agents", "SKILL.md");
-  const dst = join(CLAUDE_SKILLS_DIR, LEAD_SKILL_NAME, "SKILL.md");
+  const dst = join(target.skillsDir, LEAD_SKILL_NAME, "SKILL.md");
   const r = await copyFileIfChanged(src, dst, { refresh, dryRun, mode: 0o644 });
   if (r.missingSource) {
-    if (!quiet) process.stdout.write("  skills/okstra: runtime/agents/SKILL.md missing — skipped\n");
-    return [];
-  }
-  if (!quiet) {
-    process.stdout.write(`  skills/okstra: ${r.copied ? "copied" : "unchanged"} -> ${dst}\n`);
+    if (!quiet) {
+      process.stdout.write(
+        `  ${target.provider} skills/okstra: runtime/agents/SKILL.md missing — skipped\n`,
+      );
+    }
+    return { installed: [], copied: 0, skipped: 0 };
   }
-  return [LEAD_SKILL_NAME];
+  return { installed: [LEAD_SKILL_NAME], copied: r.copied, skipped: r.skipped };
 }
 
-async function installLeadSkillLink(repoAbs, opts) {
+async function installLeadSkillLink(repoAbs, target, opts) {
   const { dryRun, quiet } = opts;
   const src = join(repoAbs, "agents", "SKILL.md");
   if (!(await fileExists(src))) {
-    if (!quiet) process.stdout.write("  skills/okstra: <repo>/agents/SKILL.md missing — skipped\n");
+    if (!quiet) {
+      process.stdout.write(
+        `  ${target.provider} skills/okstra: <repo>/agents/SKILL.md missing — skipped\n`,
+      );
+    }
     return [];
   }
-  const dst = join(CLAUDE_SKILLS_DIR, LEAD_SKILL_NAME, "SKILL.md");
-  if (!dryRun) await fs.mkdir(join(CLAUDE_SKILLS_DIR, LEAD_SKILL_NAME), { recursive: true });
+  const dst = join(target.skillsDir, LEAD_SKILL_NAME, "SKILL.md");
+  if (!dryRun) await fs.mkdir(join(target.skillsDir, LEAD_SKILL_NAME), { recursive: true });
   const action = await ensureSymlink(src, dst, { dryRun });
-  if (!quiet) process.stdout.write(`  skills/okstra/SKILL.md: ${action}\n`);
+  if (!quiet) process.stdout.write(`  ${target.provider} skills/okstra/SKILL.md: ${action}\n`);
   return [LEAD_SKILL_NAME];
 }
 
+async function installSkillTargetsCopy(runtimeRoot, targets, opts) {
+  if (targets.length === 0) {
+    if (!opts.quiet) process.stdout.write("  skills: no Claude, Codex, or OMP agent home found — skipped\n");
+    return [];
+  }
+  return await Promise.all(targets.map((target) => installSkillsCopy(runtimeRoot, target, opts)));
+}
+
+async function installSkillTargetsLink(repoAbs, targets, opts) {
+  if (targets.length === 0) {
+    if (!opts.quiet) process.stdout.write("  skills: no Claude, Codex, or OMP agent home found — skipped\n");
+    return [];
+  }
+  return await Promise.all(targets.map((target) => installSkillsLink(repoAbs, target, opts)));
+}
+
 export function parseInstallArgs(args) {
   const result = {
     dryRun: false,
@@ -764,23 +836,22 @@ export async function runInstall(args) {
     );
   }
 
-  if (runtimeIncludesClaudeAssets(opts.runtime, runtimeResolution)) {
-    const skillResult = await installSkillsCopy(runtimeRoot, opts);
-    const leadSkillResult = await installLeadSkillCopy(runtimeRoot, opts);
-    await writeSkillsManifest(
-      paths.home,
-      [...skillResult.installed, ...leadSkillResult],
-      { dryRun: opts.dryRun },
-    );
+  const skillTargets = await detectSkillTargets();
+  const installedSkillTargets = await installSkillTargetsCopy(runtimeRoot, skillTargets, opts);
+  await writeSkillsManifest(paths.home, installedSkillTargets, { dryRun: opts.dryRun });
 
-    const agentResult = await installAgentsCopy(runtimeRoot, opts);
-    await writeAgentsManifest(paths.home, agentResult.installed, { dryRun: opts.dryRun });
-  } else if (!opts.quiet) {
-    process.stdout.write(`  claude assets: skipped for runtime=${resolvedRuntime}\n`);
+  let agentResult = { installed: [] };
+  if (skillTargets.some((target) => target.provider === "claude")) {
+    agentResult = await installAgentsCopy(runtimeRoot, opts);
   }
+  await writeAgentsManifest(paths.home, agentResult.installed, { dryRun: opts.dryRun });
 
   await installNamedTemplate(runtimeRoot, paths, { mode: "copy", ...opts }, SETTINGS_TEMPLATE_DESCRIPTOR);
-  await writeRuntimeManifest(paths.home, opts.runtime, { dryRun: opts.dryRun, resolution: runtimeResolution });
+  await writeRuntimeManifest(paths.home, opts.runtime, {
+    dryRun: opts.dryRun,
+    resolution: runtimeResolution,
+    installedAssets: installedAssetOverrides(installedSkillTargets, agentResult.installed),
+  });
 
   if (!opts.dryRun) {
     await writeFileAtomic(join(paths.home, "version"), paths.package + "\n", 0o644);
@@ -791,7 +862,7 @@ export async function runInstall(args) {
     process.stdout.write(
       "\nNext step: register the current project.\n" +
         "  cd <your project> && npx -y okstra@latest setup --project-id <id>\n" +
-        "  (or run /okstra-setup inside a Claude Code session)\n" +
+        "  (or run /okstra-setup inside a Harness Agent session (e.g. claude codex, codex, pi.. ))\n" +
         "\nTip: to use a bare 'okstra' command instead of npx, run:\n" +
         "  npm i -g okstra\n",
     );
@@ -799,6 +870,19 @@ export async function runInstall(args) {
   return 0;
 }
 
+async function skillTargetDriftReasons(targets) {
+  const reasons = [];
+  for (const target of targets) {
+    for (const name of ["okstra-run", LEAD_SKILL_NAME]) {
+      const skillPath = join(target.skillsDir, name, "SKILL.md");
+      if (!(await fileExists(skillPath))) {
+        reasons.push(`missing ${skillPath}`);
+      }
+    }
+  }
+  return reasons;
+}
+
 async function agentDriftReasons(paths) {
   const reasons = [];
   const workersDir = join(paths.agents, "workers");
@@ -886,10 +970,11 @@ export async function runEnsureInstalled(args) {
   if (!(await fileExists(join(paths.home, "schemas", "final-report-v1.0.schema.json")))) {
     reasons.push(`missing ${join(paths.home, "schemas", "final-report-v1.0.schema.json")}`);
   }
-  if (runtimeIncludesClaudeAssets(opts.runtime, runtimeResolution)) {
-    if (!(await fileExists(join(CLAUDE_SKILLS_DIR, "okstra-setup", "SKILL.md")))) {
-      reasons.push(`missing ${CLAUDE_SKILLS_DIR}/okstra-setup/SKILL.md`);
-    }
+  const skillTargets = await detectSkillTargets();
+  for (const reason of await skillTargetDriftReasons(skillTargets)) {
+    reasons.push(reason);
+  }
+  if (skillTargets.some((target) => target.provider === "claude")) {
     for (const reason of await agentDriftReasons(paths)) {
       reasons.push(reason);
     }

package/src/runtime-manifest.mjs

@@ -30,24 +30,30 @@ function defaultResolution(runtime) {
   };
 }
 
-export function buildRuntimeManifest(runtime, installedAt = new Date().toISOString(), resolution = null) {
+export function buildRuntimeManifest(
+  runtime,
+  installedAt = new Date().toISOString(),
+  resolution = null,
+  installedAssets = null,
+) {
   const runtimeResolution = resolution ?? defaultResolution(runtime);
   const includesClaude = includesClaudeRuntime(runtime, runtimeResolution);
+  const defaultAssets = {
+    sharedRuntime: true,
+    claudeSkills: includesClaude,
+    claudeAgents: includesClaude,
+    binWrappers: true,
+    templates: true,
+    schemas: true,
+    validators: true,
+  };
   return {
     schemaVersion: RUNTIME_MANIFEST_SCHEMA_VERSION,
     installedAt,
     installRequest: runtime,
     runtimeResolution,
     installedRuntimes: runtimeListForSelection(runtime, runtimeResolution),
-    installedAssets: {
-      sharedRuntime: true,
-      claudeSkills: includesClaude,
-      claudeAgents: includesClaude,
-      binWrappers: true,
-      templates: true,
-      schemas: true,
-      validators: true,
-    },
+    installedAssets: { ...defaultAssets, ...(installedAssets ?? {}) },
   };
 }
 

package/src/uninstall.mjs

@@ -51,22 +51,36 @@ const FALLBACK_AGENT_NAMES = [
   "report-writer-worker.md",
 ];
 
-const CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
-const CLAUDE_AGENTS_DIR = join(homedir(), ".claude", "agents");
+const USER_HOME = homedir();
+const CLAUDE_HOME = join(USER_HOME, ".claude");
+const CODEX_HOME = join(USER_HOME, ".codex");
+const OMP_AGENT_HOME = join(USER_HOME, ".omp", "agent");
+const CLAUDE_SKILLS_DIR = join(CLAUDE_HOME, "skills");
+const CODEX_SKILLS_DIR = join(CODEX_HOME, "skills");
+const OMP_SKILLS_DIR = join(OMP_AGENT_HOME, "skills");
+const CLAUDE_AGENTS_DIR = join(CLAUDE_HOME, "agents");
+const FALLBACK_SKILL_ROOTS = [
+  CLAUDE_SKILLS_DIR,
+  CODEX_SKILLS_DIR,
+  OMP_SKILLS_DIR,
+];
 const SKILLS_MANIFEST_REL = "installed-skills.json";
 const AGENTS_MANIFEST_REL = "installed-agents.json";
 
-const USAGE = `okstra uninstall — remove installed runtime from ~/.okstra, ~/.claude/skills, ~/.claude/agents
+const USAGE = `okstra uninstall — remove installed runtime and okstra skills
 
 Usage:
   okstra uninstall              Remove ~/.okstra/{lib (python + validators),
                                 bin/<known>, schemas, templates, version,
                                 dev-link, installed-runtimes.json,
                                 installed-skills.json, installed-agents.json} AND
-                                ~/.claude/skills/<name> AND
-                                ~/.claude/agents/<worker>.md for every
-                                entry in the install manifests (fallback:
-                                hard-coded okstra-* / *-worker.md names).
+                                every skill target recorded in
+                                installed-skills.json
+                                (~/.claude/skills, ~/.codex/skills, or
+                                ~/.omp/agent/skills). Claude worker agents are
+                                removed from ~/.claude/agents when installed.
+                                Missing manifests fall back to hard-coded
+                                Claude okstra-* / *-worker.md names.
                                 Preserves user data: recent.jsonl,
                                 active.jsonl, projects/, archive/,
                                 state.json, .locks/
@@ -74,7 +88,7 @@ Usage:
                                 (<PROJECT>/.claude/settings.local.json symlink)
                                 are NOT touched — remove them manually if needed.
   okstra uninstall --purge      Remove the entire ~/.okstra directory AND
-                                ~/.claude/skills/<okstra-*> AND
+                                okstra skills in Claude/Codex/OMP homes AND
                                 ~/.claude/agents/<*-worker.md> (DESTRUCTIVE).
                                 Requires -y or an interactive confirmation
   okstra uninstall --dry-run    Print the plan without touching disk
@@ -138,7 +152,7 @@ export async function runUninstall(args) {
   if (opts.purge) {
     if (!opts.yes && !opts.dryRun) {
       const ok = await promptConfirm(
-        `purge entire ${paths.home} AND ~/.claude/skills/{okstra-*,okstra-setup}? user data will be lost.`,
+        `purge entire ${paths.home} AND okstra skills in Claude/Codex/OMP homes? user data will be lost.`,
       );
       if (!ok) {
         process.stdout.write("aborted.\n");
@@ -148,8 +162,10 @@ export async function runUninstall(args) {
     if (!opts.quiet) process.stdout.write(`purging ${paths.home}\n`);
     await removePath(paths.home, opts);
     // Skills and worker agents live outside ~/.okstra — purge those too.
-    for (const name of FALLBACK_SKILL_NAMES) {
-      await removePath(join(CLAUDE_SKILLS_DIR, name), opts);
+    for (const root of FALLBACK_SKILL_ROOTS) {
+      for (const name of FALLBACK_SKILL_NAMES) {
+        await removePath(join(root, name), opts);
+      }
     }
     for (const name of FALLBACK_AGENT_NAMES) {
       await removePath(join(CLAUDE_AGENTS_DIR, name), opts);
@@ -190,22 +206,26 @@ export async function runUninstall(args) {
   // never removed it, leaving a stale final-report schema behind.
   await removePath(join(paths.home, "schemas"), opts);
 
-  // Remove the skills we own. Manifest is authoritative; fall back to the
-  // hard-coded okstra-* names if it is missing (e.g. an install from an old
-  // version that did not write the manifest).
+  // Remove the skills we own. Manifest v2 records every target root; legacy
+  // manifests fall back to Claude-only names when the runtime manifest says
+  // Claude assets may have been installed.
   const runtimeManifest = await readRuntimeManifest(paths.home);
-  const shouldRemoveClaudeAssets = shouldUseClaudeAssetFallback(runtimeManifest);
-  const skillNames = shouldRemoveClaudeAssets ? await readSkillsManifest(paths.home) : [];
-  if (!opts.quiet) {
-    process.stdout.write(`  skills: removing ${skillNames.length} entries from ${CLAUDE_SKILLS_DIR}\n`);
-  }
-  for (const name of skillNames) {
-    await removePath(join(CLAUDE_SKILLS_DIR, name), opts);
+  const skillTargets = await readSkillsManifest(paths.home, runtimeManifest);
+  for (const target of skillTargets) {
+    if (!opts.quiet) {
+      process.stdout.write(`  skills: removing ${target.skills.length} entries from ${target.root}\n`);
+    }
+    for (const name of target.skills) {
+      await removePath(join(target.root, name), opts);
+    }
   }
   await removePath(join(paths.home, SKILLS_MANIFEST_REL), opts);
 
-  // Remove worker agents we own. Same authoritative-manifest pattern as skills.
-  const agentNames = shouldRemoveClaudeAssets ? await readAgentsManifest(paths.home) : [];
+  // Remove worker agents we own. Agents only live in Claude Code's agent home.
+  const shouldRemoveClaudeAgents =
+    skillTargets.some((target) => target.provider === "claude") ||
+    shouldUseClaudeAssetFallback(runtimeManifest);
+  const agentNames = shouldRemoveClaudeAgents ? await readAgentsManifest(paths.home) : [];
   if (!opts.quiet) {
     process.stdout.write(`  agents: removing ${agentNames.length} entries from ${CLAUDE_AGENTS_DIR}\n`);
   }
@@ -248,15 +268,38 @@ export function shouldUseClaudeAssetFallback(runtimeManifest) {
   return runtimeManifestIncludesClaudeAssets(runtimeManifest);
 }
 
-async function readSkillsManifest(home) {
+function normalizeSkillTargets(data) {
+  if (Array.isArray(data?.targets)) {
+    return data.targets
+      .filter((target) => typeof target?.root === "string" && Array.isArray(target?.skills))
+      .map((target) => ({
+        provider: typeof target.provider === "string" ? target.provider : "unknown",
+        root: target.root,
+        skills: target.skills.filter((name) => typeof name === "string"),
+      }));
+  }
+  if (Array.isArray(data?.skills)) {
+    return [{
+      provider: "claude",
+      root: CLAUDE_SKILLS_DIR,
+      skills: data.skills.filter((name) => typeof name === "string"),
+    }];
+  }
+  return null;
+}
+
+async function readSkillsManifest(home, runtimeManifest) {
   try {
     const raw = await fs.readFile(join(home, SKILLS_MANIFEST_REL), "utf8");
     const data = JSON.parse(raw);
-    if (Array.isArray(data?.skills)) return data.skills;
+    const targets = normalizeSkillTargets(data);
+    if (targets !== null) return targets;
   } catch {
     /* fall through */
   }
-  return FALLBACK_SKILL_NAMES;
+  return shouldUseClaudeAssetFallback(runtimeManifest)
+    ? [{ provider: "claude", root: CLAUDE_SKILLS_DIR, skills: FALLBACK_SKILL_NAMES }]
+    : [];
 }
 
 async function readAgentsManifest(home) {