oris-skills 2.2.2 → 3.0.1

package/skills/oris-flow/references/verify.md

@@ -1,7 +1,7 @@
 # Verify
 
 Check every acceptance criterion against the REAL product once, with evidence. One pass,
-no loop ceremony.
+no ceremony.
 
 RULES: `references/conventions.md`. Doc standards: `references/doc-policy.md`.
 
@@ -10,7 +10,7 @@ RULES: `references/conventions.md`. Doc standards: `references/doc-policy.md`.
 1. FIND `{tasksRoot}/{task}/acceptance-criteria.md` ({task} per doc-policy). IF missing →
    offer: define criteria first (`skills/oris-flow/references/criteria.md`) | verify against a
    confirmed chat recap | stop.
-2. READ setup map + verification conventions (test commands, run scripts, environments)
+2. READ `AGENTS.md` + verification conventions (test commands, run scripts, environments)
    before improvising.
 3. PLAN one check per AC: command, test, API call, or observed behavior.
 
@@ -39,9 +39,8 @@ Date: … | Source: acceptance-criteria.md | Verified by: oris-flow verify route
 ## Change history  (date | source | change | reason)
 ```
 
-ON fix → enter `skills/oris-flow/references/fix.md` with the failing AC as the bug report.
-LONG iterative fixing with re-verification each pass → recommend
-`skills/oris-flow/references/loop.md` only when one fix-verify pass is clearly not enough.
+ON fix → enter `skills/oris-flow/references/fix.md` with the failing AC as the bug report;
+re-verify the fixed criteria afterwards, as many fix-verify passes as the user approves.
 
 ## Never
 

package/agents/oris-loop-debriefer.md

@@ -1,30 +0,0 @@
----
-name: oris-loop-debriefer
-description: Learns across Oris Loop receipts and tunes the loop prompts (improve.mode auto) or proposes changes (propose). Use after passes complete.
-readonly: false
----
-
-You are the Oris Loop debriefer.
-
-Rules:
-
-1. Use receipts and referenced evidence only; no durable pattern from a single weak signal.
-2. Separate design problems from execution, environment, verifier, and changed-goal problems.
-3. improve.mode auto: you may rewrite files under the loop's `prompts/` — copy the old file to `history/` first, note the change for the receipt. One improvement per debrief.
-4. improve.mode propose: write the smallest evidence-backed change to `proposals/`; change nothing else.
-5. NEVER touch loop.md scope, limits, permissions, or verification — always a proposal.
-   NEVER weaken verification to make passes green — fix the loop, not the bar.
-6. Keep the summary compact.
-
-Output:
-
-```json
-{
-  "role": "debriefer",
-  "outcome": "keep|tuned|proposed|execution-issue|environment-blocked|inconclusive",
-  "insight": "",
-  "changedFiles": [],
-  "proposalPath": "",
-  "nextAction": ""
-}
-```

package/agents/oris-loop-doctor.md

@@ -1,32 +0,0 @@
----
-name: oris-loop-doctor
-description: Diagnoses Oris Loop run evidence and decides whether to continue, block, ask the user, or propose a minimal loop patch.
-readonly: true
----
-
-You are the Oris Loop Doctor.
-
-Rules:
-
-1. Diagnose from receipts and verifier evidence, not confidence.
-2. Distinguish loop design issues from execution mistakes, verifier issues,
-   environment failures, changed goals, and insufficient evidence.
-3. Do not patch the loop directly.
-4. Propose the smallest loop change only when evidence shows the loop design is
-   the problem.
-5. Require approval for changes to scope, authority, commands, paths, stop
-   rules, risk, credentials, or external systems.
-
-Output:
-
-```json
-{
-  "role": "doctor",
-  "decision": "continue|advance|complete|ask-user|propose-patch|blocked",
-  "diagnosis": "",
-  "evidence": "",
-  "patchSummary": "",
-  "approvalRequired": true,
-  "nextAction": ""
-}
-```

package/agents/oris-loop-executor.md

@@ -1,35 +0,0 @@
----
-name: oris-loop-executor
-description: Performs one bounded action for an approved Oris Loop pass. Use only when the orchestrator provides loop scope, current phase, allowed paths, and verification intent.
-readonly: false
----
-
-You are the Oris Loop executor.
-
-Rules:
-
-1. Verify the task includes `ORIS LOOP ACTIVE`.
-2. Read only the loop definition, context, and files in declared scope.
-3. Perform exactly one bounded action. Re-read the fresh state of every file
-   you touch before editing it. The action proves bigger than bounded → stop
-   and return blocked with what you found; half-done work is worse than none.
-4. Preserve unrelated user work.
-5. Do not commit, push, deploy, write DevOps, send external messages, expose
-   credentials, or edit `.oris-flow/runtime/**`.
-6. Return a compact result with changed files, claim, risk, and suggested
-   verifier check. claim = what changed + the exact command or observation
-   that proves it.
-
-Output:
-
-```json
-{
-  "role": "executor",
-  "state": "claimed|blocked",
-  "summary": "",
-  "changedFiles": [],
-  "claim": "",
-  "evidenceHint": "",
-  "blocker": ""
-}
-```

package/agents/oris-loop-verifier.md

@@ -1,35 +0,0 @@
----
-name: oris-loop-verifier
-description: Independently verifies an Oris Loop executor claim using declared project evidence. Use after an executor reports a bounded action.
-readonly: true
----
-
-You are the Oris Loop verifier.
-
-Rules:
-
-1. Do not trust the executor claim without evidence. Run the checks FIRST,
-   judge after — a claim you could not check is inconclusive, never pass.
-2. Use the verification command, static check, browser evidence, or review rule
-   declared by the loop.
-3. Do not edit product files — you only observe, never fix.
-4. Keep raw logs out of the orchestrator response; point to evidence files when
-   available.
-5. Report pass, fail, blocked, or inconclusive.
-
-Output:
-
-```json
-{
-  "role": "verifier",
-  "state": "pass|fail|blocked|inconclusive",
-  "goalMet": false,
-  "summary": "",
-  "evidence": "",
-  "evidencePath": "",
-  "failureSignal": "",
-  "nextRecommendation": ""
-}
-```
-
-`goalMet` is true only when the loop goal itself is satisfied, not just this pass.

package/references/loop-adapter.schema.json

@@ -1,93 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://oris.dev/schemas/oris-loop-adapter-v1.json",
-  "title": "Oris Loop Repository Adapter",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["$schema", "schemaVersion", "repository", "paths", "commands", "preflight"],
-  "properties": {
-    "$schema": {
-      "const": "https://oris.dev/schemas/oris-loop-adapter-v1.json"
-    },
-    "schemaVersion": {
-      "const": 1
-    },
-    "repository": {
-      "type": "string",
-      "minLength": 1
-    },
-    "paths": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["runtime", "allowed", "protected"],
-      "properties": {
-        "taskRoots": {
-          "type": "array",
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/relativePath" }
-        },
-        "runtime": { "$ref": "#/$defs/relativePath" },
-        "loops": { "$ref": "#/$defs/relativePath" },
-        "allowed": {
-          "type": "array",
-          "minItems": 1,
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/relativePath" }
-        },
-        "protected": {
-          "type": "array",
-          "uniqueItems": true,
-          "items": { "$ref": "#/$defs/relativePath" }
-        },
-        "testDir": { "$ref": "#/$defs/relativePath" }
-      }
-    },
-    "commands": {
-      "type": "object",
-      "minProperties": 1,
-      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
-      "additionalProperties": { "$ref": "#/$defs/command" }
-    },
-    "models": {
-      "type": "object",
-      "description": "Model alias map per repository, e.g. { \"smart\": \"composer-2.5\" }; loop.md can reference aliases",
-      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
-      "additionalProperties": { "type": "string", "minLength": 1 }
-    },
-    "preflight": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["minFreeDiskGiB"],
-      "properties": {
-        "minFreeDiskGiB": {
-          "type": "number",
-          "minimum": 0
-        }
-      }
-    }
-  },
-  "$defs": {
-    "relativePath": {
-      "type": "string",
-      "minLength": 1,
-      "not": { "pattern": "(^|[\\\\/])\\.\\.([\\\\/]|$)" }
-    },
-    "command": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["executable", "args", "cwd"],
-      "properties": {
-        "executable": { "type": "string", "minLength": 1 },
-        "args": {
-          "type": "array",
-          "items": { "type": "string" }
-        },
-        "cwd": { "$ref": "#/$defs/relativePath" },
-        "requiresFreeDiskGiB": {
-          "type": "number",
-          "minimum": 0
-        }
-      }
-    }
-  }
-}

package/references/loop-contract.md

@@ -1,126 +0,0 @@
-# Oris Loop Contract (v2)
-
-An Oris loop is a project-local feedback system: observe → choose ONE bounded action → act → verify with real evidence → record → repeat or stop. It is never permission for work outside its approved scope.
-
-## Layout — everything lives in the project
-
-```text
-.oris-flow/
-  adapter.json          repo adapter (paths, commands, model aliases) — `npx oris-skills loop bootstrap`
-  loops/{slug}/
-    loop.md             approved contract (front matter below)
-    prompts/            one editable file per ACTIVE role
-      orchestrator.md   injected each pass by the stop hook (optional; default shipped)
-      executor.md       required
-      verifier.md       required
-      doctor.md         only when roles includes doctor
-      debriefer.md      only when roles includes debriefer (required for improve.mode: auto)
-    context.md          living handoff snapshot (facts, next action)
-    receipts/           one compact receipt per pass
-    proposals/          unapproved improvement patches
-    history/            archived loop.md and prompt versions
-  runtime/              machine-owned state — agents NEVER edit it
-```
-
-## loop.md front matter (the runtime contract)
-
-```yaml
----
-schemaVersion: 2
-kind: oris-loop
-name: my-loop            # stable slug
-approved: true           # set by the user's approval at craft — loop cannot start without it
-phases: [work]
-roles: [executor, verifier]   # default; opt in doctor and/or debriefer only when needed
-limits:
-  maxIterations: 10
-  maxNoProgress: 2       # consecutive passes without verified progress → blocked
-  maxMinutes: 240
-models:                  # per-role: "inherit" | adapter alias | platform model id
-  default: inherit
-  verifier: inherit      # override any role independently
-improve:
-  mode: propose          # propose | auto (auto = debriefer may rewrite prompts/ between passes)
-permissions:
-  allowedPaths: []
-  forbiddenActions: [commit, push, deploy, external-message]
-verification:
-  commands: []
-  evidenceRequired: true
----
-Goal: one sentence.
-Stop: one sentence.
-```
-
-Schema: `references/loop.schema.json`. Body = human summary; prompts live in `prompts/`, never inline.
-`approved: true` marks user approval of goal, scope, prompts, and limits. It never authorizes work outside the loop.
-
-## Roles
-
-Default roles are **executor + verifier** — enough for most loops. Opt in `doctor` (multi-phase loops with non-trivial stop logic) and `debriefer` (long unattended runs that should learn across passes) via `roles:` in loop.md.
-
-| Role | Default | Does | Never |
-|------|---------|------|-------|
-| orchestrator (main chat) | always | reads context, spawns roles, writes receipts, sets state | executor/verifier/doctor work |
-| executor | yes | ONE bounded action per pass | self-verify, exceed scope |
-| verifier | yes | independent evidence check per user criteria; sets `goalMet` when the LOOP goal is satisfied | trust claims, edit product files |
-| doctor | opt-in | decision from evidence: `continue \| advance \| complete \| ask-user \| propose-patch \| blocked` (canonical enum — every doctor prompt uses exactly these) | edit files, patch loop.md |
-| debriefer | opt-in | learn across receipts; tune prompts (auto) or propose (propose) | touch scope/limits/permissions |
-
-Without a doctor, the verifier verdict maps to the state directly: `pass` + `goalMet` → complete; `pass`/`fail` → continue; `blocked`/`inconclusive` → ask-user.
-
-Every prompt is a file the user can edit; the next pass obeys the edited file. The executor prompt carries the literal gate `ORIS LOOP ACTIVE` — executors refuse tasks without it. Subagent output is a single ```json fenced block; raw logs go to `.oris-flow/runtime/evidence/`. Read-only roles (verifier, doctor) run without write permission in headless mode.
-
-## Models
-
-`inherit` → the current session's model (no explicit model passed).
-Adapter aliases → `adapter.json` `models: { "smart": "<platform-model-id>" }`; loop.md references the alias, so the same loop.md ports across platforms.
-Anything else → passed through as a platform model id.
-
-## Triggers per platform
-
-| Platform | Mechanism |
-|----------|-----------|
-| Cursor | `.cursor/hooks.json` stop hook → injects the next pass into the same chat |
-| Claude Code | `.claude/settings.json` Stop hook → `decision: block` continues the same session |
-| Codex / CI | `npx oris-skills loop run` — each role is a separate CLI process |
-
-`npx oris-skills loop bootstrap` writes adapter + hooks + wrappers. The injected pass message comes from `prompts/orchestrator.md` (or the shipped default) with `{{placeholders}}` filled from runtime state.
-
-## States and outcomes
-
-Machine states: `continue` | `advance` | `complete` | `ask-user` | `blocked` | `cancelled`.
-`ask-user` pauses the loop for input or approval — the hook stops resuming until the state is set back to `continue` (or the loop is restarted). It is NOT a failure.
-Receipt results: `Success` | `Clean no-op` | `Blocked` | `Approval required` | `Exhausted` | `No progress`.
-Every `set-state` carries `--progress yes|no` (yes = the verifier confirmed forward movement); `maxNoProgress` consecutive `no` passes force `blocked`.
-Hitting any limit without meeting the goal = `blocked`, NEVER success.
-
-## Receipt (per pass)
-
-```markdown
-# Oris Loop Receipt
-Loop: <slug> | Pass: <n> | Result: <outcome>
-Scope: <inspected/changed>
-Check: <verification + conditions>
-Evidence:
-- <summary + pointer>
-Actions:
-- <bounded action + outcome>
-Improved: <prompt tuned this pass, or none>
-Next: <next action | approval | blocker | nothing>
-```
-
-No secrets, no private reasoning, no full transcripts in receipts.
-
-## Self-improvement
-
-- `improve.mode: auto` → debriefer may rewrite `prompts/*.md` (archive old file to `history/` first, note the change in the receipt). One improvement per pass, evidence-backed.
-- `improve.mode: propose` → every change lands in `proposals/` until the user approves.
-- BOTH modes: scope, limits, permissions, verification commands change only via approved proposal; previous `loop.md` → `history/loop.vN.md`.
-
-## Iteration rules
-
-- Re-read fresh state before consequential actions; preserve unrelated user work.
-- Only declared paths, commands, tools, and data policy.
-- NEVER: commit, push, branch, PR, deploy, DevOps writes, external messages, credential exposure — unless the loop explicitly permits that exact action.
-- Real verification before claiming success. Update only `context.md`, receipts, and declared write scopes.

package/references/loop.schema.json

@@ -1,156 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://oris.dev/schemas/oris-loop-v2.json",
-  "title": "Oris Loop document front matter (v2)",
-  "type": "object",
-  "additionalProperties": true,
-  "required": [
-    "schemaVersion",
-    "kind",
-    "name",
-    "approved",
-    "phases",
-    "limits",
-    "permissions",
-    "verification"
-  ],
-  "properties": {
-    "schemaVersion": {
-      "const": 2
-    },
-    "kind": {
-      "const": "oris-loop"
-    },
-    "name": {
-      "type": "string",
-      "pattern": "^[a-z0-9]+(?:[._-][a-z0-9]+)*$",
-      "minLength": 2,
-      "maxLength": 80
-    },
-    "approved": {
-      "type": "boolean",
-      "description": "true only after the user approved goal, scope, prompts, and limits"
-    },
-    "models": {
-      "type": "object",
-      "additionalProperties": true,
-      "description": "Per-role model: \"inherit\" (session model), an adapter alias, or a platform model id",
-      "properties": {
-        "default": { "$ref": "#/$defs/model" },
-        "executor": { "$ref": "#/$defs/model" },
-        "verifier": { "$ref": "#/$defs/model" },
-        "doctor": { "$ref": "#/$defs/model" },
-        "debriefer": { "$ref": "#/$defs/model" }
-      }
-    },
-    "improve": {
-      "type": "object",
-      "additionalProperties": true,
-      "properties": {
-        "mode": {
-          "enum": ["propose", "auto"],
-          "description": "auto lets the debriefer rewrite prompts/ between passes; propose requires user approval for every change"
-        }
-      }
-    },
-    "phases": {
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 12,
-      "items": {
-        "type": "string",
-        "pattern": "^[a-z][a-z0-9-]*$"
-      }
-    },
-    "roles": {
-      "type": "array",
-      "description": "Active roles per pass. Default [executor, verifier]; opt in doctor and/or debriefer. Executor and verifier are always required.",
-      "minItems": 2,
-      "uniqueItems": true,
-      "items": {
-        "enum": ["executor", "verifier", "doctor", "debriefer"]
-      },
-      "allOf": [
-        { "contains": { "const": "executor" } },
-        { "contains": { "const": "verifier" } }
-      ]
-    },
-    "limits": {
-      "type": "object",
-      "required": [
-        "maxIterations",
-        "maxNoProgress"
-      ],
-      "additionalProperties": true,
-      "properties": {
-        "maxIterations": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 500
-        },
-        "maxNoProgress": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 50
-        },
-        "maxMinutes": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 1440
-        }
-      }
-    },
-    "permissions": {
-      "type": "object",
-      "required": [
-        "allowedPaths",
-        "forbiddenActions"
-      ],
-      "additionalProperties": true,
-      "properties": {
-        "allowedPaths": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "forbiddenActions": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        }
-      }
-    },
-    "verification": {
-      "type": "object",
-      "required": [
-        "commands",
-        "evidenceRequired"
-      ],
-      "additionalProperties": true,
-      "properties": {
-        "commands": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "evidenceRequired": {
-          "type": "boolean"
-        }
-      }
-    }
-  },
-  "$defs": {
-    "model": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 120
-    }
-  }
-}

package/references/repo-map.md

@@ -1,51 +0,0 @@
-# Oris Repository Map
-
-Setup map = the default project context for every Oris skill and loop. It exists so agents stop re-scanning and users stop repeating project facts.
-
-## Files
-
-| File | Scope | Purpose |
-|------|-------|---------|
-| `.oris-flow/manifest.json` | repo | compact index: section paths, freshness, confidence |
-| `.oris-flow/maps/**` | repo | short markdown maps: docs, stack, commands, code areas, tests |
-| `.oris-flow/adapter.json` | repo | loop adapter: paths, commands, model aliases |
-| `.oris-flow/settings.json` | repo | preferences: `responseStyle` + `artifactLanguage` (non-secret) |
-| `{tasksRoot}/{task}/…` | task | business artifacts only — `setup.tasksRoot` in the manifest, default `.oris-flow/tasks` (see `references/doc-policy.md`) |
-
-Manifest and maps are never task authority and NEVER hold secrets.
-
-## Manifest shape (v1)
-
-```json
-{
-  "$schema": "https://oris.dev/schemas/oris-flow-map-v1.json",
-  "schemaVersion": 1,
-  "repository": "",
-  "generatedAt": "",
-  "updatedAt": "",
-  "setup": { "versionControl": { "orisFlowMap": "commit" } },
-  "sections": {}
-}
-```
-
-- Small: only sections that exist for the detected stack; no placeholders.
-- Each section: file path, one-line summary, `confidence`, `lastScannedAt`, stale flag.
-- Confidence: `confirmed` (user/authoritative) | `detected` (strong scan evidence) | `inferred` (unverified) | `stale` (no longer matches).
-- `setup.versionControl.orisFlowMap`: `commit` | `gitignore` — applied via `npx oris-skills flow version-control --mode <choice>`.
-- Schema: `references/repo-map.schema.json`.
-
-## Map sections
-
-`.oris-flow/maps/`: `README.md`, `docs.md`, `stack.md`, `commands.md`, `code.md`, `tests.md`.
-Each section: purpose, authoritative paths, confirmed decisions, key commands/conventions, confidence + stale notes, pointers instead of copied content.
-
-## Consumption rules
-
-1. MANIFEST first, then only the relevant map sections — before any broad scan.
-2. VERIFY stale or high-risk facts against the repository before consequential actions.
-3. Loops: the orchestrator passes relevant setup-map facts into role prompts at craft time; users never repeat project facts per loop.
-4. SUGGEST `/oris-flow` → Setup refresh only when a stale gap materially affects the task.
-
-## Command surface
-
-In target repositories always use the installed CLI (`npx oris-skills flow scan|version-control|clean-runtime`, `npx oris-skills loop …`), never `node scripts/...` paths — those exist only in the OrisSkills source checkout.