Package proven operator workflows as a Codex plugin

.agents/plugins/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "robert-ray-oss",
+  "interface": {
+    "displayName": "Robert Ray OSS"
+  },
+  "plugins": [
+    {
+      "name": "codex-operator-kit",
+      "source": {
+        "source": "local",
+        "path": "./"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}

.codex-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "codex-operator-kit",
+  "version": "0.5.0",
+  "description": "Reusable workflows for reliable agent-assisted software maintenance.",
+  "author": {
+    "name": "Robert Ray",
+    "url": "https://github.com/TheRobertRay"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Codex Operator Kit",
+    "shortDescription": "Reliable routing, review, loops, and verification.",
+    "longDescription": "A focused collection of maintainer workflows for turning rough requests into bounded work, coordinating agents without write conflicts, verifying live behavior, and publishing reusable operator material safely.",
+    "developerName": "Robert Ray",
+    "category": "Productivity",
+    "capabilities": [],
+    "defaultPrompt": "Help me choose and apply the smallest Codex Operator Kit workflow that fits this maintenance task."
+  }
+}

.github/PULL_REQUEST_TEMPLATE.md

@@ -6,12 +6,16 @@
 
 - [ ] Issue triage
 - [ ] Prompt/skill workflow
+- [ ] Routing, delegation, or agent loop
+- [ ] Live-surface verification
+- [ ] Plugin or installation
 - [ ] Validation or release tooling
 - [ ] Documentation or example
 
 ## Validation
 
 - [ ] `bash scripts/validate.sh`
+- [ ] `bash scripts/plugin-smoke.sh` when plugin packaging changed
 - [ ] Public/private context reviewed
 - [ ] Release notes or changelog updated when user-facing behavior changed
 

AGENTS.md

@@ -27,3 +27,11 @@
 - For long-running, trust-sensitive, or multi-step work, run an adversarial completion review before calling the task done.
 - Challenge the completion claim against success criteria, constraints, evidence, likely regressions, and hidden assumptions.
 - A task is done only when critic findings are fixed, accepted as residual risk, or escalated.
+
+## Public Workflow Extraction
+
+- Preserve the reusable decision rule, not private project detail.
+- Remove local paths, hostnames, credentials, account identifiers, private product names, and transport metadata.
+- Label inference as inference and do not turn private usage into a public adoption claim.
+- Keep plugin metadata, install docs, skill inventory, and changelog version aligned.
+- Run `bash scripts/validate.sh` after material changes and `bash scripts/plugin-smoke.sh` when plugin packaging changes.

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.5.0 - 2026-07-17
+
+- Packaged the collection as an installable Codex plugin with a repository marketplace.
+- Added Command Center routing, bounded agent loop, live-surface verification, and shared-context skills.
+- Added an operator field guide, shared-context architecture note, worker and verification templates, and three worked examples.
+- Updated standalone skill installation to the current user skill location and made replacement require explicit `--force`.
+- Added an isolated plugin marketplace/install smoke test and expanded structural validation.
+- Refreshed the Codex for Open Source application packet as a conservative update to the June submission.
+
 ## 0.4.0 - 2026-06-02
 
 - Added a first-impression README pass with clearer maintainer use cases and public validation/release badges.

CONTRIBUTING.md

@@ -8,6 +8,7 @@ This repository accepts small, copyable workflow improvements for AI-assisted so
 - A skill that turns a repeated maintenance workflow into a reusable checklist
 - A validation check that catches stale placeholders or missing safety gates
 - Documentation that makes a maintainer workflow easier to repeat
+- A sanitized workflow extracted from repeated real use, with provenance and a verifier
 
 ## Not In Scope
 
@@ -23,3 +24,4 @@ Every change should answer:
 1. What maintainer problem does this reduce?
 2. What false-pass path does it prevent?
 3. How can another maintainer validate that it works?
+4. What private source details were intentionally generalized or excluded?

README.md

@@ -2,94 +2,150 @@
 
 [![validate](https://github.com/TheRobertRay/codex-operator-kit/actions/workflows/validate.yml/badge.svg)](https://github.com/TheRobertRay/codex-operator-kit/actions/workflows/validate.yml)
 [![release](https://img.shields.io/github/v/release/TheRobertRay/codex-operator-kit?label=release)](https://github.com/TheRobertRay/codex-operator-kit/releases/latest)
+[![license](https://img.shields.io/github/license/TheRobertRay/codex-operator-kit)](LICENSE)
 
-Reusable prompt contracts, review gates, and maintenance workflows for running coding agents on real repositories without losing source-of-truth discipline.
+Small, reusable workflows for running coding agents on real repositories without losing ownership, evidence, or source-of-truth discipline.
 
-If you maintain software with coding agents in the loop, this kit gives you copyable operating patterns for the work that usually breaks trust: ambiguous task intake, issue and PR triage, delegated implementation, release readiness, and public/private context screening.
+The kit packages the operator patterns that tend to matter after the first impressive demo: turning rough input into the right task, coordinating workers without duplicate writes, bounding autonomous loops, proving the real user-facing path, and extracting public lessons without leaking private context.
 
-This repository is intentionally small. It packages worked-through operator patterns into files that other maintainers can copy into their own repos:
-
-- `AGENTS.md` prompt intake contract for ambiguous or dictated tasks
-- conversation capture receipts for rough chat, voice notes, and inbox dumps
-- maintainer triage skill for evidence-first issue and PR review
-- milestone review skill for substantial implementation work
-- application packet template for programs that evaluate OSS maintainer signal
-- validation and publication-risk scripts that check for broken placeholders, missing sections, and private-context leaks
-- public examples for issue triage, PR review, and release-readiness gates
+It is intentionally a toolkit, not an agent framework.
 
 ## What You Can Use Today
 
 | Maintainer problem | Use this | Outcome |
 | --- | --- | --- |
-| Rough user input turns into the wrong task | `templates/AGENTS.md` and `conversation-capture-receipts` | A clear receipt before writes happen |
-| Agent work passes local checks but misses the real risk | `milestone-review` and completion critic gates | A second pass against false-positive completion |
-| Private workflow knowledge needs to become public OSS material | `docs/publication-risk.md` and `scripts/check-publication-risk.sh` | Sanitized examples without private paths, hostnames, or secrets |
-| A maintainer wants to try the kit quickly | `scripts/install-skills.sh` and `docs/quick-demo.md` | A dry-run and temp install path before touching an existing setup |
+| Rough input may become the wrong task or write | `conversation-capture-receipts` | A human-readable understanding receipt before persistence |
+| One main conversation coordinates several lanes | `command-center-routing` | Clear ownership, bounded workers, and compact user decisions |
+| Autonomous work needs a real finish line | `bounded-agent-loops` | Goal, verifier, state, stop conditions, and approval boundary |
+| An issue, PR, bounty, or application claim needs evidence | `oss-maintainer-triage` | Conservative claims and the smallest grounded next action |
+| Substantial work may look complete while still failing | `milestone-review` | A review against false-pass paths and residual risk |
+| A live route or workflow is broken | `live-surface-verification` | Proof through the exact layer and user path that failed |
+| Several agents need the same current reality | `shared-context-briefs` | Provenance, freshness, expiry, and current-input priority |
+| Private workflow knowledge needs to become public | publication-risk gate | Sanitized examples without private paths, hosts, or credentials |
+
+The [Operator Field Guide](docs/operator-field-guide.md) helps choose the smallest workflow. The [shared-context pattern](docs/shared-context-pattern.md) covers safe context exchange between several agents without copying raw transcripts.
 
-## Current Status
+## Install As A Codex Plugin
 
-Codex Operator Kit was published on 2026-06-01 as a public OSS workspace for Codex operator workflows. It is intentionally compact: copyable contracts, skills, examples, and validation checks that can be reused by maintainers.
+The plugin bundles all skills and is the recommended install path for current Codex versions.
 
-## Who This Is For
+```bash
+codex plugin marketplace add TheRobertRay/codex-operator-kit --ref main
+codex plugin add codex-operator-kit@robert-ray-oss
+```
 
-This kit is for maintainers who use coding agents to:
+Verify the install:
+
+```bash
+codex plugin list --marketplace robert-ray-oss
+```
 
-- triage issues and pull requests without skipping evidence
-- delegate bounded subtasks to subagents
-- run adversarial completion checks before claiming work is done
-- keep user-facing summaries separate from machine artifacts
-- avoid false-pass paths during deployment, cleanup, and trust-sensitive changes
+See [Install And Use](docs/install-and-use.md) for the standalone-skill path, safe temporary installs, updates, and removal.
 
-## Quick Start
+## Try It Without Changing Your Setup
 
-Copy the contract into a repository:
+Clone the repo and run:
 
 ```bash
-cp templates/AGENTS.md AGENTS.md
+bash scripts/validate.sh
+demo_target="$(mktemp -d)/skills"
+bash scripts/install-skills.sh --target "$demo_target" command-center-routing
 ```
 
-Try the maintainer demo in `docs/quick-demo.md` first if you want a temporary install path.
+Then ask Codex:
 
-Copy one or more skills into your local Codex skills directory when you are ready to use them in your setup:
+```text
+Read skills/command-center-routing/SKILL.md and examples/command-center-routing.md.
+Turn this mixed maintainer request into the lightest safe execution shape, one
+bounded worker packet if useful, and a compact final receipt:
 
-```bash
-bash scripts/install-skills.sh --dry-run
-bash scripts/install-skills.sh
+"The release job is failing, onboarding copy still feels wrong, and I need a
+summary for tomorrow. Handle what you can and only bring me real decisions."
 ```
 
-Validate this repository:
+The full [Quick Demo](docs/quick-demo.md) stays inside a temporary target.
+
+## Copyable Assets
+
+### Skills
+
+- `conversation-capture-receipts`
+- `command-center-routing`
+- `bounded-agent-loops`
+- `oss-maintainer-triage`
+- `milestone-review`
+- `live-surface-verification`
+- `shared-context-briefs`
+
+### Templates
+
+- [Bounded Worker Packet](templates/worker-packet.md)
+- [Verification Contract](templates/verification-contract.md)
+- [Repository Agent Contract](templates/AGENTS.md)
+
+### Worked Examples
+
+- [Conversation capture receipt](examples/conversation-capture-receipt.md)
+- [Command Center routing](examples/command-center-routing.md)
+- [Bounded documentation loop](examples/bounded-loop.md)
+- [Issue triage](examples/issue-triage.md)
+- [PR review gate](examples/pr-review-gate.md)
+- [Live-surface verification](examples/live-surface-verification.md)
+- [Release readiness](examples/release-readiness.md)
+
+## Maintenance Model
+
+The core loop is simple:
+
+1. Convert rough input into a concrete outcome.
+2. Select the lightest execution shape.
+3. Give delegated work exact scope and stop rules.
+4. Make the smallest change that can satisfy the outcome.
+5. Verify the layer that actually failed.
+6. Challenge completion when the risk justifies it.
+7. Return a compact receipt.
+8. Promote repeated, public-safe patterns into skills.
+
+Read [Maintenance Model](docs/maintenance-model.md) for the full rationale.
+
+## Validation
+
+Repository validation checks required assets, skill metadata, documentation coverage, standalone installation, plugin and marketplace structure, application field limits, and common publication risks:
 
 ```bash
 bash scripts/validate.sh
 ```
 
-Run the publication-risk scanner directly:
+When the Codex CLI is installed, exercise an isolated marketplace and plugin install:
 
 ```bash
-bash scripts/check-publication-risk.sh
+bash scripts/plugin-smoke.sh
 ```
 
+The smoke test uses a temporary Codex home and does not alter the user's configured marketplaces or installed plugins.
+
 ## Repository Map
 
-- `templates/AGENTS.md` - compact global intake and completion-review contract
-- `skills/conversation-capture-receipts/SKILL.md` - no-write receipt workflow for messy human input
-- `skills/oss-maintainer-triage/SKILL.md` - issue, PR, and bounty-style evidence triage
-- `skills/milestone-review/SKILL.md` - milestone and adversarial completion review workflow
-- `docs/maintenance-model.md` - the operating model behind the kit
-- `docs/install-and-use.md` - installer and adoption guide
-- `docs/quick-demo.md` - short maintainer demo path
-- `docs/workflows.md` - copyable maintainer workflows
-- `docs/publication-risk.md` - how to screen workflow packs before publishing
-- `examples/` - sanitized example packets and receipts
-- `docs/codex-for-oss-application.md` - application packet and field-ready answers
-- `scripts/validate.sh` - local validation checks
-- `scripts/install-skills.sh` - install all or selected skills into a Codex skills directory
-- `scripts/check-publication-risk.sh` - conservative private-context leak scanner
-
-## Maintenance Posture
-
-The project is maintained as a practical operator kit rather than a framework. New additions should be small, copyable, and tied to a maintenance workflow that has been used in real work.
+- `.codex-plugin/plugin.json` - plugin manifest
+- `.agents/plugins/marketplace.json` - repo marketplace
+- `skills/` - reusable Codex workflows
+- `templates/` - copyable contracts
+- `examples/` - sanitized worked examples
+- `docs/operator-field-guide.md` - workflow selector
+- `docs/shared-context-pattern.md` - provenance, freshness, and expiry architecture
+- `docs/publication-risk.md` - public/private extraction gate
+- `docs/codex-for-oss-application.md` - conservative application packet
+- `scripts/validate.sh` - repository checks
+- `scripts/plugin-smoke.sh` - isolated plugin installation check
+- `scripts/install-skills.sh` - standalone skill installer
+- `scripts/check-publication-risk.sh` - private-context scanner
+
+## Project Status
+
+Codex Operator Kit is an early public OSS project maintained through visible issues, pull requests, releases, CI, and public validation. Public adoption is still early, so the project makes no claim of broad usage.
+
+New contributions should stay small, copyable, grounded in a repeated maintenance failure, and accompanied by a way to validate the improvement.
 
 ## License
 
-MIT. See `LICENSE`.
+MIT. See [LICENSE](LICENSE).

docs/codex-for-oss-application.md

@@ -1,6 +1,6 @@
-# Codex for OSS Application Packet
+# Codex for Open Source Application Packet
 
-This packet is written for the OpenAI Codex for Open Source form as of 2026-06-01. It should be reviewed before submission, but it is ready to paste.
+This packet matches the public OpenAI Codex for Open Source form reviewed on 2026-07-17. It is written as a transparent update to an application first submitted on 2026-06-01.
 
 ## Public Fields
 
@@ -19,33 +19,48 @@ https://github.com/TheRobertRay/codex-operator-kit
 Role:
 
 ```text
-Primary maintainer of Codex Operator Kit, a small public workflow kit that packages reusable prompt contracts, review gates, and validation habits for maintainers using coding agents on real repositories.
+Primary maintainer of Codex Operator Kit, an open-source collection of reusable skills, templates, examples, and validation checks for reliable agent-assisted software maintenance.
 ```
 
 Why this repository qualifies, 500 characters max:
 
 ```text
-Codex Operator Kit is an early public OSS maintainer workflow project. It packages field-tested prompt contracts, milestone reviews, adversarial completion checks, and triage habits used in real maintenance work. It is small, but directly aligned with Codex for OSS: reducing review, triage, validation, and release-risk load for maintainers using coding agents.
+Codex Operator Kit is an active OSS workflow pack for maintainers using coding agents. It ships seven reusable skills plus worker and verification templates, plugin installation, CI validation, and release/triage examples. Its practical ecosystem value is reducing false completion, context leaks, coordination conflicts, and live-verification failures in agent-assisted maintenance.
 ```
 
 How API credits would be used, 500 characters max:
 
 ```text
-I would use API credits to test Codex-based maintainer automation: issue/PR triage, review-packet generation, stale-context detection, milestone review, and release-readiness checks. The goal is to turn repeated agent maintenance patterns into reusable, validated OSS workflows without leaking private project data.
+I would use credits to run reproducible evaluations for issue and PR triage, bounded worker routing, release readiness, live-surface verification, and context-safety checks, then publish sanitized fixtures, failure cases, and validation improvements. Credits would support this public repository and its maintainer automation, not private operational workloads.
 ```
 
 Anything else, 500 characters max:
 
 ```text
-This is a newly public repo, so public adoption signals are still early. The reason I am applying now is that the workflows come from repeated real maintenance runs across private and local systems, and I want to harden them in public for other maintainers. I will keep claims conservative and publish only sanitized, reusable operator material.
+This updates my June 1 application after a material v0.5.0 expansion. The repository now installs as a Codex plugin and has seven skills, six releases, validated examples, and a visible issue/PR/release trail. Adoption is still early: no stars, forks, or external contributors yet; GitHub reported four unique clones in the latest 14-day window when checked July 17.
 ```
 
-## Recommended Checkboxes
+## Recommended Selection
 
-- ChatGPT Pro / Codex access
-- API credits for project
-- Codex Security only if the form allows interest without claiming current security scale
+- Role: Primary maintainer
+- Interest: API credits for my project
+- Codex Security: leave unselected unless a future code-heavy security surface justifies it
 
-## Honest Risk
+## Evidence
 
-This repository does not yet have broad public adoption, stars, downloads, or an external contributor base. The application should lean on clear ecosystem fit and real maintainer workflow value, not inflated usage claims.
+- Public repository with MIT license
+- Seven installable skills
+- Codex plugin manifest and repository marketplace
+- Worker and verification templates
+- Sanitized public examples
+- Validation and publication-risk scripts
+- Issue, pull request, release, and GitHub Actions history
+- Isolated plugin install smoke test
+
+## Honest Limits
+
+- The project is active but still early.
+- It has no stars, forks, or external contributors as of 2026-07-17.
+- Clone traffic does not prove ongoing adoption and should not be described as users.
+- Private and local usage supports workflow provenance, not public adoption.
+- Selection remains OpenAI's judgment; this packet should not imply guaranteed eligibility.