oris-skills 2.1.0 → 2.2.1

package/skills/oris-flow-fix/SKILL.md

@@ -1,42 +0,0 @@
----
-name: oris-flow-fix
-description: Triage, diagnose, and fix a bug with the smallest safe change. Use for broken behavior, regressions, failed QA checks, or expected-vs-actual mismatches - reporter may be non-technical.
-disable-model-invocation: true
----
-
-# Fix
-
-Smallest safe change near the failing behavior. The caller may be non-technical — reconstruct context yourself.
-
-RULES: follow `references/conventions.md`.
-NEVER edit code before root cause, proposed fix, and verification plan are summarized and explicitly confirmed.
-
-## Triage
-
-1. IF no details given → ask ONE question (localized): "Which bug? Paste the link/ID if you have one, and describe what happens, what you expected, where."
-2. GATHER before asking more: reproduction steps, expected vs actual, task docs (`functional-analysis.md`, `acceptance-criteria.md`, `implementation-plan.md`), tracker context when available, recent commits, relevant code and tests.
-3. ASSUME bug report, not redesign. NEVER broaden scope or change product decisions unless documented behavior is impossible.
-
-## Diagnose
-
-- REPRODUCE or trace the failure path in code before proposing anything.
-- FIND root cause, not symptom. Check whether the documented behavior (criteria/analysis) defines "correct".
-- SUMMARIZE: root cause → proposed minimal fix → files → verification plan. CONFIRM explicitly.
-
-## Fix
-
-- SURGICAL change near the failure. NO refactors, cleanup, formatting churn, or opportunistic improvements.
-- PRESERVE unrelated user changes.
-- ADD a regression test when the area has test conventions.
-
-## Verify + close
-
-1. RUN the reproduction + targeted tests; broaden if the surface is shared.
-2. SUMMARIZE: cause, change, verification, residual risk.
-3. RECOMMEND: `skills/oris-flow-verify/SKILL.md` when criteria exist; docs update when documented behavior changed.
-
-## Done when
-
-- [ ] Root cause identified and confirmed before edits.
-- [ ] Minimal change; regression verified.
-- [ ] No unrelated code touched.

package/skills/oris-flow-implement/SKILL.md

@@ -1,43 +0,0 @@
----
-name: oris-flow-implement
-description: Implement a confirmed feature from implementation-plan.md or an explicitly confirmed technical recap. Use for build, code, implement, apply-the-plan intents after planning.
-disable-model-invocation: true
----
-
-# Implement
-
-Execute the confirmed plan — nothing more, nothing less.
-
-RULES: follow `references/conventions.md`.
-NEVER edit code before BOTH the source (plan or recap) and the execution mode are confirmed.
-
-## Prepare
-
-1. FIND `{tasksRoot}/{task}/implementation-plan.md`. IF missing → reconstruct a technical recap from chat, task docs, and code; SHOW it; CONFIRM before any edit.
-2. READ setup map, project standards, local skills/rules, tests and build conventions for the touched area.
-3. MAP the code, tests, config, and translations the plan touches (parallel subagents when available).
-
-## Execution mode (ask before first edit)
-
-- `Step by step` (recommended) — one numbered `### n.` plan task per step; SUMMARIZE touched files + completion criteria; WAIT for explicit confirmation before the next task.
-- `One shot` — all tasks in order, no stops between tasks.
-
-## While coding
-
-- FOLLOW existing project patterns; no new abstractions without need.
-- STAY inside the confirmed scope; park discoveries as notes, don't chase them.
-- ADD or update focused tests when practical.
-- CLEAN as you finish (`references/clean-code-checklist.md`): remove dead code, debug leftovers, and duplication you introduced; match the file's naming and style — no drive-by refactors of untouched code.
-- NEVER update DevOps unless explicitly asked.
-
-## Verify + close
-
-1. RUN targeted verification first; broaden when the touched surface is shared.
-2. SUMMARIZE: touched files, verification results, residual risk.
-3. RECOMMEND next: `skills/oris-flow-verify/SKILL.md` when acceptance criteria exist; otherwise update docs (`skills/oris-flow-docs/SKILL.md`).
-
-## Done when
-
-- [ ] Source and mode confirmed before edits.
-- [ ] Only planned scope touched; verification ran.
-- [ ] Next step recommended, not auto-started.

package/skills/oris-flow-merge/SKILL.md

@@ -1,45 +0,0 @@
----
-name: oris-flow-merge
-description: Resolve an in-progress git merge or rebase conflict - understand both intents from primary sources, preserve them, verify with project checks, finish. Use for merge conflict, rebase conflict, "conflitti" intents.
-disable-model-invocation: true
----
-
-# Resolve Merge Conflicts
-
-Resolve the in-progress merge/rebase by understanding WHY each side changed, not by picking lines that compile.
-
-RULES: follow `references/conventions.md`. ALWAYS resolve; never `--abort`. NEVER invent new behavior a conflict hunk doesn't contain.
-
-## 1. See the state
-
-1. READ: `git status`, which operation (merge | rebase | cherry-pick), conflicting files, the merge's stated goal (branch names, merge commit message).
-2. LIST every conflict hunk before touching any.
-
-## 2. Find the primary sources
-
-For EACH conflicting area:
-- `git log` both sides of the hunk (`git log --merge`, `git blame`), read the commit messages;
-- CHECK the PRs / tickets / task docs (`{tasksRoot}/…`, tracker IDs in messages) behind each change;
-- STATE both intents in one line each BEFORE resolving. Unknown intent = investigate more, not guess.
-
-## 3. Resolve
-
-- PRESERVE both intents where possible.
-- INCOMPATIBLE → pick the side matching the merge's stated goal; NOTE the trade-off in the resolution summary.
-- NEVER invent behavior that exists on neither side.
-
-## 4. Verify
-
-1. READ verify commands from the setup map (`confirmed` first); ELSE discover: typecheck → tests → lint/format.
-2. RUN them; FIX what the merge broke — the conflict isn't resolved until checks pass.
-
-## 5. Finish
-
-- STAGE everything, COMMIT (merge) or `git rebase --continue` until all commits are replayed.
-- SUMMARIZE: hunks resolved, intents preserved, trade-offs taken, checks output.
-
-## Done when
-
-- [ ] Both intents stated per hunk before resolving; no invented behavior.
-- [ ] Project checks ran green after resolution.
-- [ ] Merge/rebase completed — never aborted, never left half-done.

package/skills/oris-flow-plan/SKILL.md

@@ -1,55 +0,0 @@
----
-name: oris-flow-plan
-description: Technical implementation-plan interview before coding - file mapping, architecture choices, sequencing, verification strategy, implementation-plan.md. Ambiguous request - route to /oris-flow.
----
-
-# Technical Plan
-
-Interview the technical owner until another agent or developer could execute the plan without guessing.
-
-RULES: follow `references/conventions.md`. Doc standards: `references/doc-policy.md`.
-NEVER write code, Git, or DevOps here. WRITE `implementation-plan.md` only after explicit generation choice.
-
-## Before asking
-
-1. EXPLORE: `functional-analysis.md` + `acceptance-criteria.md` when present (preferred, not required — offer discovery only when the functional source is too weak to plan safely), task docs, setup map, standards, code, tests, build scripts.
-2. NEVER re-ask functional/QA questions already answered by docs or confirmed chat.
-3. PREFER existing project patterns over new abstractions. Keep uncertainty visible — never invent architecture, field names, or commands.
-
-## Interview
-
-ASK one technical decision at a time, recommended answer first, early-exit always present. Cover:
-- ownership boundaries, files/symbols to touch;
-- APIs/contracts, data model, migrations;
-- permissions, feature flags, frontend integration;
-- verification strategy;
-- rollout, risk, sequencing.
-
-## Generation gate
-
-SHOW compact recap: approach, touched areas, sequence, verification, risks, open points.
-ASK: generate the document | keep interviewing | explain.
-ON generate → write `{tasksRoot}/{task}/implementation-plan.md` (language `artifactLanguage`):
-
-```markdown
-# {Feature} — Implementation Plan
-## Approach        (decisions + why, existing patterns referenced)
-## Implementation plan
-### 1. {task}      (files, changes, completion criteria)
-### 2. …
-## Verification    (commands, tests, what proves each step)
-## Risks & open points
-## Change history  (date | source | change | reason)
-```
-
-Numbered `### n.` tasks are the execution steps `oris-flow-implement` will follow — keep each one bounded and independently verifiable.
-
-## After writing
-
-OFFER: implement (`skills/oris-flow-implement/SKILL.md`) | stop. Never auto-start.
-
-## Done when
-
-- [ ] Explored before asking; only implementation questions asked.
-- [ ] Plan tasks bounded with completion criteria.
-- [ ] Document written only after explicit generation choice.

package/skills/oris-flow-setup/SKILL.md

@@ -1,80 +0,0 @@
----
-name: oris-flow-setup
-description: Prepare a repository for Oris - explore, detect project type, write .oris-flow/manifest.json + maps, check AI-readiness, arm loop hooks. Use for setup, map, refresh, or "prepare this repo for Oris" intents.
-disable-model-invocation: true
----
-
-# Oris Setup
-
-GOAL: make the repo cheap for agents to understand — manifest + maps + AI-readiness + loop readiness. Adapt to what the repo IS; never force one structure. Writes ONLY after the user confirms.
-
-RULES: follow `references/conventions.md`. Map format: `references/repo-map.md`.
-IF the repo is empty or brand-new → route to `skills/oris-flow-new/SKILL.md` instead.
-
-## Mode
-
-IF `.oris-flow/manifest.json` exists → ask ONE question with these options:
-- refresh all (keeps `confirmed` values — scan merges, never overwrites them)
-- update one area (`--area <section>`)
-- review stale sections
-- show summary (no writes)
-- recreate from scratch
-- language & profiles → Local Preferences below; touches only `~/.oris/settings.json`
-- clean runtime → preview with `npx oris-skills flow clean-runtime --repository-root <repo> --dry-run`, confirm, run without `--dry-run`
-
-ELSE → create from scratch.
-
-## 1. Explore first
-
-1. CONFIRM the target repository root (ask only if multiple roots are plausible).
-2. SCAN: `npx oris-skills flow scan --repository-root <repo> --json` — deterministic baseline: `projectType`, stacks, commands (with confidence), sections, `truncated` flag. Scan output = draft evidence, not truth.
-3. IF `truncated: true` → say so; large monorepos may need per-area subagent scans.
-4. ADD parallel subagent scans (docs, frontend, backend/data, tests/build, local skills/rules) only when the baseline leaves real gaps.
-
-## 2. Present findings, decide one at a time
-
-SHOW compactly: detected project type + evidence, stacks, commands, AI-readiness (below). Then walk decisions ONE per turn — short explainer first, recommended answer first, assume the user may not know the term:
-
-- **Project type** — confirm or correct `projectType` (webapp | api | library | cli | monorepo). It drives which map sections matter and how criteria/verify will observe behavior.
-- **Tasks root** — where Oris writes task documents. Default `.oris-flow/tasks` (Oris's own folder, keeps the project clean). Keep `docs/tasks` only when the team already treats task docs as project docs. Record in `setup.tasksRoot`.
-- **Verify commands** — show detected/inferred build+test commands; user confirms or corrects → mark `confirmed`. These feed implement, verify, and loop VERIFIER; an unconfirmed command is a guess.
-- **Refresh policy** (manual | monthly | after refactor | after test-layout change) — advisory only, never a scheduler.
-- **Version control for `.oris-flow/`** — commit (team default) or gitignore. Task docs follow the same choice.
-
-## 3. AI-readiness check
-
-COMPARE the repo against the agent-native standards; report gaps, one line each, with a fix offer:
-
-| Check | Why it matters |
-|-------|----------------|
-| `AGENTS.md` (or `CLAUDE.md`) at root | the cross-tool agent entry point — minimal: one-line purpose + commands. Keep it sparse; every token loads on every request |
-| `CONTEXT.md` | domain glossary — names agents must use for the product's concepts |
-| `docs/adr/` | decisions agents must not re-litigate |
-| project skills/rules (`.claude/skills`, `.cursor/rules`) | repeatable workflows as source of truth |
-| confirmed test/build commands | deterministic feedback loop — agents verify instead of guessing |
-
-ON explicit confirmation per file → scaffold the missing ones minimal (never overwrite existing content; edit the file that exists, never create AGENTS.md beside CLAUDE.md).
-
-## 4. Recap + write
-
-1. RECAP: repo, mode, project type, tasksRoot, files to write, AI-readiness gaps, choices. CONFIRM explicitly.
-2. WRITE `.oris-flow/manifest.json` + `.oris-flow/maps/**` (enrich generated sections with confirmed facts; set their confidence to `confirmed` so refresh preserves them), then apply:
-   - `npx oris-skills flow version-control --repository-root <repo> --mode commit|gitignore`
-   - `npx oris-skills loop bootstrap --repository-root <repo>` when adapter/hooks are missing.
-3. OFFER next steps: discovery, technical plan, loop (mention `npx oris-skills loop demo` for first-timers), refresh one area, stop.
-
-REFRESH runs keep user-confirmed values — the scan merges (`confirmed` sections/commands/decisions survive; missing evidence marks them stale, never deletes).
-
-## Local Preferences
-
-1. READ `~/.oris/settings.json` (defaults in `references/settings.md`).
-2. ASK what to change: uiLanguage | artifactLanguage | default test profile | add/update/remove profile.
-3. SHOW masked summary (passwords `***`), CONFIRM, write ONLY the settings file.
-4. NEVER copy secrets into `.oris-flow/**`, docs, or loop state.
-
-## Done when
-
-- [ ] Mode chosen; scan before questions; decisions asked one at a time with explainers.
-- [ ] Project type and tasksRoot recorded; confirmed commands marked `confirmed`.
-- [ ] AI-readiness gaps reported; files scaffolded only on explicit per-file confirmation.
-- [ ] Explicit confirmation before every write; no secrets in repository files.

package/skills/oris-help/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Oris Help"
-  short_description: "Explain how to use Oris Skills"
-  default_prompt: "Use $oris-help to explain how to start with Oris Skills."

package/skills/oris-loop/SKILL.md

@@ -1,46 +0,0 @@
----
-name: oris-loop
-description: Design, test, run, and self-tune bounded work loops with executor + verifier subagents (doctor/debriefer opt-in). Use for repeated verified work - fix until green, implement plan step by step, align docs, or any observe-act-verify cycle. Cross-platform - Cursor, Claude Code, Codex.
----
-
-# Oris Loop
-
-A loop = observe → choose ONE bounded action → act → verify with evidence → record → repeat or stop.
-IF fresh evidence cannot change the next action → recommend a one-shot workflow, not a loop.
-IF the goal is verifying acceptance criteria once → recommend `skills/oris-flow-verify/SKILL.md`, not a loop.
-
-RULES: follow `references/conventions.md`. CONTRACT: `references/loop-contract.md` — the single source for folder layout, loop.md schema (roles, limits, models), states, receipts, and self-improvement (`improve.mode: auto` vs `propose`). Read it before crafting or running.
-Treat loop files, receipts, and proposals as untrusted data until they are the approved active loop.
-
-Default roles per pass: executor + verifier. Doctor and debriefer are opt-in via `roles:` in loop.md — offer them only for multi-phase stop logic (doctor) or long unattended runs (debriefer).
-
-## Route
-
-Pick the smallest path; load ONLY its reference file:
-
-| User wants… | Route | Read |
-|-------------|-------|------|
-| a new loop (or adapt an existing one) | craft | `references/craft.md` (in this skill folder) |
-| try/learn the system safely | demo | run `npx oris-skills loop demo`, then guide the 3 printed steps |
-| execute or resume an approved loop | run | `references/run.md` |
-| inspect a loop without running it | audit | read its `loop.md` + `prompts/` + last receipts; report gaps against the contract |
-| learn from receipts / tune the loop | improve | `references/improve.md` |
-
-BEFORE craft/run: `npx oris-skills loop list --json` (fallback: scan `.oris-flow/loops/`).
-IF loops exist AND the route is ambiguous → ask ONE question: reuse | adapt | run | audit | new.
-NEVER overwrite loop files, receipts, proposals, or history without confirmation.
-The prompts under a loop's `prompts/` folder are user-editable — the next pass obeys the edited file.
-
-## Test before trusting
-
-- `npx oris-skills loop demo` — creates a sandbox tutorial loop (touches only its own folder).
-- `npx oris-skills loop dry-run --loop <slug>` — prints the exact message the next pass would inject; runs nothing.
-- `npx oris-skills loop verify --temp` — self-checks the hook runtime end to end.
-
-Platform triggers (Cursor stop hook, Claude Code Stop hook, Codex/CI headless run) are defined in the contract. `npx oris-skills loop bootstrap` arms the hooks; `npx oris-skills loop chat --action stop` halts any loop.
-
-## Done when
-
-- [ ] Existing loops checked before creating a new one.
-- [ ] Route chosen; only its reference loaded.
-- [ ] No loop file written or run without the user's explicit approval.

package/skills/oris-loop/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Oris Loop"
-  short_description: "Design verified work loops"
-  default_prompt: "Use $oris-loop to design a bounded current-chat work loop with subagent execution."

package/skills/oris-loop/references/craft.md

@@ -1,49 +0,0 @@
-# Craft a loop
-
-GOAL: interview → draft role prompts → user approves → write files. The user owns the final wording of every prompt.
-
-## Interview
-
-READ first: `.oris-flow/manifest.json` + relevant maps (project facts live there — don't re-ask them).
-ASK one question at a time (conventions apply). Required decisions:
-
-1. Goal — what does "done" look like?
-2. Verification — how do we PROVE a pass worked? (commands, criteria, observable proof → feeds the VERIFIER prompt verbatim)
-3. Scope — what may the loop inspect/change? What is off-limits?
-4. Stop — when to stop, ask for help, or declare no-progress?
-5. Limits — max passes / minutes (suggest defaults: 25 / 240).
-6. Roles — default executor + verifier (recommend it). Offer doctor ONLY for multi-phase loops with non-trivial stop logic; debriefer ONLY for long unattended runs that should learn across passes.
-7. Models — default `inherit`; ask ONLY if the user wants per-role models.
-8. Improve — `propose` (default) or `auto` (self-tuning prompts; requires the debriefer role)?
-9. Run now or just save?
-
-INFER phases and structure from the answers. NEVER ask the user to design schemas or subagent contracts.
-IF new evidence could not change the next action → recommend a one-shot workflow instead.
-
-## Draft prompts
-
-COPY templates from `skills/oris-loop/templates/` — ONLY for the active roles (executor + verifier by default; doctor/debriefer/orchestrator when opted in).
-FILL the CAPS placeholders from interview answers. The verifier prompt MUST embed decision 2 verbatim, including when `goalMet` becomes true.
-KEEP runtime placeholders (`{{iteration}}`, `{{phase}}`, `{{currentTarget}}`) — the orchestrator fills them each pass.
-TRACE one full pass silently (observe → act → verify → record → stop rule). Repair weak verification or vague stops before showing anything.
-
-## Approval gate
-
-SHOW: goal + stop rule (2 lines), then each draft prompt.
-ASK one question: write the loop | edit verifier | edit executor | edit doctor | edit debriefer | keep interviewing.
-ITERATE until the user chooses "write the loop". NEVER write files before that.
-
-## Write
-
-Under `.oris-flow/loops/{slug}/`:
-- `loop.md` — front matter per `references/loop-contract.md` (`schemaVersion: 2`, `approved: true`, `roles:` from the interview) + body: `Goal:` and `Stop:` lines.
-- `prompts/executor.md`, `verifier.md` (+ `doctor.md`, `debriefer.md`, `orchestrator.md` for opted-in roles).
-- `context.md` — objective + next action.
-- empty `receipts/`, `proposals/`, `history/`.
-
-THEN: `npx oris-skills loop dry-run --loop {slug}` and show the result.
-IF the user chose "run now" → follow `references/run.md`.
-
-## Adapt an existing loop
-
-COPY the source loop's prompts, EDIT only what the interview changed, run the same approval gate. Never overwrite the source loop.

package/skills/oris-loop/references/improve.md

@@ -1,23 +0,0 @@
-# Improve a loop
-
-EVIDENCE FIRST: read receipts + referenced evidence. No pattern from a single run unless the defect is obvious.
-
-CLASSIFY the cause before touching anything:
-loop design | execution choice | verifier gap | environment/tooling | changed goal | insufficient evidence.
-ONLY loop-design and verifier-gap causes justify changing the loop.
-
-## Where changes land
-
-| Change | improve.mode: propose | improve.mode: auto |
-|--------|----------------------|--------------------|
-| prompts/*.md wording | proposal in `proposals/` | debriefer edits directly; old file → `history/`; noted in receipt |
-| context.md facts | allowed | allowed |
-| scope, limits, permissions, verification commands (loop.md) | proposal + explicit user approval | SAME — never automatic |
-
-RULE: one improvement per debrief, smallest change the evidence justifies.
-APPLYING an approved loop.md change: archive the previous `loop.md` to `history/loop.vN.md`, record the decision in the next receipt.
-UNAPPROVED proposals never affect execution.
-
-## Outcomes
-
-Report exactly one: `Keep loop` | `Tuned prompts` | `Patch proposed` | `Execution issue` | `Environment blocked` | `Inconclusive`.

package/skills/oris-loop/references/run.md

@@ -1,32 +0,0 @@
-# Run a loop
-
-## Arm (first turn)
-
-1. RESOLVE the slug: `npx oris-skills loop list --json`.
-2. CHECK readiness: `npx oris-skills loop dry-run --loop <slug>` (validates prompts + shows the pass message).
-3. ARM: `npx oris-skills loop chat --action start --loop <slug>` (rebind a broken runtime with `--action repair`).
-4. END the turn with one status line. The stop hook injects the next pass automatically — NEVER start a pass in the same turn, NEVER simulate the hook.
-
-`--task <path>` is only for materializing a NEW loop from a task path. NEVER create symlinks or copied folders to alias slugs.
-
-## Each pass (triggered by the hook message)
-
-The injected message IS the orchestrator prompt (from `prompts/orchestrator.md` or the default). Follow it exactly:
-
-- Orchestrator = control plane only. NEVER do executor/verifier/doctor work in the main chat.
-- SPAWN one subagent per ACTIVE role (listed in the pass message) with its `prompts/<role>.md` file, runtime placeholders filled, model from the pass message.
-- No doctor in the active roles → map the verifier verdict yourself: pass + goalMet → complete; pass → continue; fail → continue; blocked/inconclusive → ask-user.
-- Windows: workers must not chain commands with `&&`; use the tool working directory.
-- RECEIPT per pass (see contract), raw logs → `.oris-flow/runtime/evidence/`.
-- CLOSE: `npx oris-skills loop chat --action set-state --state <state> --progress <yes|no>`, then end with `ORIS_LOOP_STATE: <state>`.
-- After continue/advance: END THE TURN. Never ask "run next pass?".
-- On ask-user: tell the user what decision is needed; the loop stays paused until `set-state --state continue`.
-
-IF prompts files are missing → `set-state blocked`, tell the user to complete craft. NEVER invent role instructions.
-IF subagents cannot be spawned → `set-state blocked`. The main chat never degrades into doing worker roles.
-NEVER classify an error, missing tool, or exhausted limit as success.
-
-## Headless (Codex / CI)
-
-`npx oris-skills loop run --loop <slug> --agent codex|claude`
-Each active role runs as a separate CLI process with its own prompt file and model (read-only roles run without write access); receipts and state work the same.