theslopmachine 1.0.3 → 1.0.6

package/MANUAL.md

@@ -1,96 +1,56 @@
-# theslopmachine manual
-
-## What it is
-
-theslopmachine installs the workflow-owner agents, the developer agents, Claude runtime assets, and the supporting skills/templates needed to run the delivery workflow inside OpenCode and the Claude-backed path.
+# SlopMachine v2 Manual
 
 ## Install
 
-Run:
+Run from this repository:
 
-```bash
-slopmachine setup
+```sh
+npm install
+npm link
+slopmachine install
 ```
 
-This installs:
+The installer copies OpenCode agents to `~/.config/opencode/agents`, Claude assets to `~/.claude`, shared skills to `~/.agents/skills`, and slopmachine assets to `~/slopmachine`.
+
+## Initialize A Task
 
-- agents into `~/.config/opencode/agents/`
-- skills into `~/.agents/skills/`
-- Claude runtime assets into `~/.claude/`
-- theslopmachine-owned files into `~/slopmachine/`
-- scaffold playbooks into `~/slopmachine/scaffold-playbooks/`
-- the post-bugfix coverage/README audit prompt into `~/slopmachine/test-coverage-prompt.md`
-- merged plugin/MCP config into `~/.config/opencode/opencode.json`
+```sh
+slopmachine init /path/to/task-root
+```
 
-The installed agent set includes the current `slopmachine`, `slopmachine-claude`, and `developer` agents.
+The initialized root is intentionally sparse and packaging-friendly. Product code belongs in `repo/`; product-facing docs belong in `docs/`; final kept reports belong in `.tmp/`; project facts belong in `metadata.json`.
 
-The installed scaffold system includes:
+Use `--claude` for `slopmachine-claude` runs:
 
-- one shared Docker/runtime/test contract
-- one generic unknown-tech scaffold guide
-- family matrices for frontend, backend, database, platform, and overlays
-- concrete verified or partial-proof playbooks for the common scaffold families
+```sh
+slopmachine init --claude /path/to/task-root
+```
 
-## Start a project
+The active developer rulebook is recorded in `../.ai/metadata.json` as `developer_rulebook_file`. The unused rulebook is removed from the task folder.
 
-Inside a new or empty project directory, run:
+## Continue From A Phase Alias
 
-```bash
-slopmachine init
+```sh
+slopmachine init --continue-from P5 /path/to/task-root
 ```
 
-Or to open OpenCode immediately in `repo/` after bootstrap:
+Legacy aliases remain accepted for CLI compatibility, but owner-facing language uses Phase 1 through Phase 8.
+
+## Developer Rulebooks
 
-```bash
-slopmachine init -o
+OpenCode developer agents read `AGENTS.md`. Claude developer agents read `CLAUDE.md`. Only the selected rulebook is seeded into a task root. These files are product engineering rulebooks, not owner workflow instructions.
+
+## Verification
+
+For this package:
+
+```sh
+npm run typecheck
+npm run check
 ```
 
-## What `init` does
-
-- creates `.ai/` workflow files plus `.ai/artifacts`
-- creates hidden `.ai/worktrees/` as the default location for parallel git worktrees
-- initializes git when needed
-- updates `.gitignore`
-- bootstraps beads_rust (`br`)
-- creates parent-root `docs/`, `.tmp/`, `metadata.json`, and root `.beads/`
-- creates `repo/`
-- copies the packaged default repo rulebook into `repo/AGENTS.md`
-- copies the packaged Claude repo rulebook into `repo/CLAUDE.md`
-- seeds `repo/README.md`, `repo/plan.md`, and `repo/.claude/settings.json`
-- seeds `.ai/startup-context.md` plus the parent-root planning docs under `docs/`
-- later, when `P5` closes, the workflow preserves the final truthful execution record in `docs/plan.md` and removes `repo/plan.md` before evaluation begins
-- creates the initial git commit so the workspace starts with a clean tree
-- optionally opens `opencode` in `repo/`
-- parallel worktrees should stay under hidden parent-root `.ai/worktrees/` so the visible workspace root stays clean
-
-## Rough workflow
-
-1. Intake and setup
-2. Clarification
-3. Planning
-4. Development, starting with the scaffold step inside `plan.md`
-5. Rough integrated verification and hardening: repo coherence and small owner-side fixes only, with no Docker execution
-6. Evaluation and fix verification, including the final coverage and README audit inside `P7`
-7. Final readiness decision
-8. Submission packaging, including the owner-only Docker and `./run_tests.sh` check
-9. Retrospective
-
-The intended fast path is:
-
-- plan well
-- land the minimal scaffold baseline
-- execute the plan end to end
-- make the repo coherent
-- proceed through evaluation without Docker execution
-- after evaluation is complete, have the owner run and fix `docker compose up --build` and `./run_tests.sh` before submission closes
-
-## Important notes
-
-- theslopmachine depends on Node.js/npm, OpenCode, beads_rust (`br`), git, python3, and Docker being available.
-- Unix-like setup paths also depend on `bash` and `curl`, and Linux fallback archive handling depends on `tar`.
-- the Claude-backed path also depends on the `claude` CLI plus `tmux`.
-- packaging and send-data depend on archive support: `zip` on non-Windows systems or PowerShell on Windows.
-- The workflow-owner agents use mandatory skills for specific phases; skipping them is considered a workflow failure.
-- `slopmachine` is the lighter current engine: it keeps the owner prompt smaller, uses more specialized skills, and keeps one active developer session at a time while preserving rollover history when new sessions are intentionally started.
-- the scaffold playbook inventory now covers the main repeated families used in current tasks: React/Vite, Vue/Vite, Angular, FastAPI, Spring Boot, Django, Laravel, Livewire, Go/Chi, Android Java Views, Android Kotlin Compose, Electron/Vite, Tauri, Expo iOS-on-Linux, plus honest Linux partial-proof native Swift and Objective-C iOS playbooks.
-- Submission packaging collects the final docs, accepted evaluation reports, cleaned OpenCode session exports or one Claude session zip bundle containing only the tracked relevant Claude sessions, and the cleaned repo into the required final structure.
+For generated product repos, developer lanes should run targeted, relevant verification unless explicitly asked to run Docker or `run_tests.sh`.
+
+## Asset Continuity
+
+`src/constants.js` defines the required packaged slopmachine assets. Installation and initialization should only refer to files present under `assets/`.

package/README.md

@@ -1,347 +1,72 @@
-# theslopmachine
+# SlopMachine v2
 
-`theslopmachine` installs and bootstraps the SlopMachine workflow for OpenCode.
+SlopMachine is a local project bootstrap and workflow CLI for generating, reviewing, verifying, and packaging software delivery tasks with OpenCode and Claude support.
 
-It configures:
-
-- the `slopmachine` owner agent
-- the `slopmachine-claude` owner agent
-- the `developer` implementation agent
-- required skills under `~/.agents/skills/`
-- Claude worker runtime assets under `~/.claude/`
-- workflow support files under `~/slopmachine/`, including scaffold playbooks
-- the post-bugfix coverage/README audit prompt at `~/slopmachine/test-coverage-prompt.md`
-- OpenCode MCP entries for `context7` and `exa`
+This v2 package keeps the existing installer and CLI behavior while updating the bundled agents, skills, prompts, templates, and workflow guidance around an eight-phase owner process.
 
 ## Requirements
 
-- Node.js 18+
-- `npm`
-- `git`
-- Docker
-- `python3`
-- `bash` on Unix-like systems
-- `curl` on Unix-like systems
-- `tar` on Linux for fallback archive handling
-- `opencode`
-- `br` (`beads_rust`)
-- `tmux` for the `slopmachine-claude` live bridge
-- `claude` for the `slopmachine-claude` backend
-- `zip` on non-Windows systems for packaging and send-data archives
-- PowerShell on Windows for packaging and send-data archives
-
-`slopmachine setup` verifies or installs what it can.
-
-## Install
+- Node.js 18 or newer
+- macOS, Linux, or WSL
+- `opencode` for OpenCode owner and developer agents
+- Claude Code for Claude live developer sessions, when using Claude lanes
+- `br` from beads-rust for task lifecycle tracking
 
-From this package directory:
+## Install From This Repo
 
-```bash
+```sh
 npm install
-npm run check
-npm pack
-npm install -g ./theslopmachine-<version>.tgz
-slopmachine setup
-```
-
-If you install a freshly packed local tarball, rerun `slopmachine setup` before bootstrapping a workspace so the installed home assets under `~/slopmachine`, `~/.config/opencode/agents`, and `~/.agents/skills` are refreshed to match the package you just installed.
-
-For local development instead:
-
-```bash
 npm link
+slopmachine install
 ```
 
-## Commands
-
-### `slopmachine setup`
-
-Use this once per machine, then rerun any time you want to refresh packaged assets.
-
-```bash
-slopmachine setup
-```
-
-What it does:
-
-- verifies or installs `opencode`
-- verifies `npm`, `br`, `git`, `python3`, Docker, and the Claude/live-bridge packaging dependencies
-- installs packaged agents into `~/.config/opencode/agents/`
-- installs packaged skills into `~/.agents/skills/`
-- installs Claude runtime assets into `~/.claude/`
-- installs workflow files into `~/slopmachine/`
-- installs scaffold playbooks into `~/slopmachine/scaffold-playbooks/`
-- installs `~/slopmachine/test-coverage-prompt.md` for the final post-bugfix audit
-- updates `~/.config/opencode/opencode.json`
-- ensures packaged MCP entries for `context7` and `exa`
-- optionally asks for an upload token if one is not already stored
-
-Notes:
-
-- existing upload token is preserved and setup skips that prompt when one already exists
-- existing `context7` and `exa` entries are preserved if already configured
-- package-managed assets are refreshed on rerun
-- scaffold assets now include a shared Docker contract, family matrices, and concrete default playbooks under `~/slopmachine/scaffold-playbooks/`
-
-Current scaffold inventory includes:
-
-- shared Docker/runtime/test contract
-- generic unknown-tech scaffold guide
-- frontend, backend, database, platform, and overlay family matrices
-- experimentally verified concrete playbooks for:
-  - React/Vite
-  - Vue/Vite
-  - Angular
-  - FastAPI
-  - Spring Boot
-  - Django
-  - Laravel
-  - Livewire
-  - Go/Chi
-  - Android Java Views
-  - Android Kotlin Compose
-  - Electron/Vite desktop
-  - Tauri desktop
-  - Expo iOS-on-Linux
-- experimentally verified Linux partial-proof playbooks for:
-  - native Swift iOS
-  - native Objective-C iOS
-
-These playbooks are baseline-only references. The redesigned workflow uses them to define the scaffold step at the start of development inside `plan.md` before the single broad implementation run continues.
-
-### `slopmachine init`
-
-Use this in a new or empty project directory to create a SlopMachine workspace.
+`slopmachine install` installs bundled agents, Claude assets, shared skills, slopmachine prompt assets, utility scripts, and MCP config entries under the current user home.
 
-```bash
-mkdir my-project
-cd my-project
-slopmachine init
-```
-
-Or open OpenCode immediately after bootstrap:
-
-```bash
-slopmachine init -o
-```
-
-To adopt an existing project into a SlopMachine workspace and request a later workflow starting phase:
-
-```bash
-slopmachine init --adopt --phase P3
-```
-
-Equivalent smoother existing-project bootstrap:
-
-```bash
-slopmachine init --continue-from P3
-```
-
-What it creates:
-
-- `repo/`
-- `docs/`
-- `.tmp/`
-- `metadata.json`
-- `.ai/metadata.json`
-- `.ai/startup-context.md`
-- hidden `.ai/worktrees/` for parallel git worktrees when used
-- root `.beads/`
-- `repo/AGENTS.md`
-- `repo/CLAUDE.md`
-- `repo/plan.md`
-- `repo/.claude/settings.json`
-- `repo/README.md`
-- `docs/questions.md`
-- `docs/design.md`
-- `docs/api-spec.md`
-- `docs/plan.md`
-- `docs/test-coverage.md`
-
-Important details:
-
-- `run_id` is created in `.ai/metadata.json`
-- the workspace root is the parent directory containing `repo/`
-- parent-root `.tmp/` is the audit and fix-check artifact directory used during `P7`
-- parent-root `.tmp/` also holds `test_coverage_and_readme_audit_report.md` after the final post-bugfix audit
-- parent-root `metadata.json` is strict project metadata only and must contain exactly these keys: `prompt`, `project_type`, `frontend_language`, `backend_language`, `database`, `frontend_framework`, `backend_framework`
-- `project_type` should use only `fullstack`, `backend`, `android`, `ios`, `desktop`, or `web` when known
-- Beads lives in the workspace root, not inside `repo/`
-- `repo/.claude/settings.json` seeds Claude Code to use the custom `developer` agent by default for that repo
-- planned parallel git worktrees should live under hidden parent-root `.ai/worktrees/` by default so root-level `repo-lane-*` folders do not clutter the workspace
-- when `P5` completes, the workflow moves `repo/plan.md` to parent-root `docs/plan.md`; packaging later validates that `repo/plan.md`, `repo/AGENTS.md`, and `repo/CLAUDE.md` are absent from the delivered `repo/`
-- after non-`-o` bootstrap, the command prints the exact `cd repo` next step so you can continue immediately
-- `--adopt` moves the current project files into `repo/`, preserves root workflow state in the parent workspace, and skips the automatic bootstrap commit
-- `--continue-from <PX>` is a smoother alias for existing-project bootstrap; it implies adoption mode and seeds the requested start phase in one step
-- if `--continue-from <PX>` is run while your current working directory is already the real project `repo/`, or if the explicit target path itself points at that `repo/` directory, SlopMachine automatically treats `..` as the workspace root and writes the workflow state there instead of creating `repo/repo`
-- when a later start phase is seeded for adoption or recovery, the Beads workflow phases before that requested phase are created and immediately marked completed so tracker state matches the seeded entry point
-- in the `slopmachine-claude` path, if adopted or resumed later-phase work has no recoverable tracked Claude developer session yet, the owner must launch and orient the needed Claude lane first and only then continue the substantive work in that same session
-- `--phase <PX>` seeds the initial `current_phase` for adoption/recovery bootstrap; the owner should still fall back if the real repo evidence does not support that later phase
-- `repo/plan.md` is seeded at bootstrap and becomes the definitive repo-local execution checklist through planning, development, and `P5`; after `P5`, the preserved reference copy is `docs/plan.md`
-
-### `slopmachine set-token`
-
-Stores the upload token used by `send-data`.
+## Commands
 
-```bash
+```sh
+slopmachine --help
+slopmachine install
+slopmachine init <target-dir>
+slopmachine init --claude <target-dir>
 slopmachine set-token
 ```
 
-Behavior:
-
-- prompts for the plaintext upload token
-- stores it in `~/.config/slopmachine/config.json`
-- replaces an existing token if one is already stored
-- does not validate the token over the network during entry
-
-### `slopmachine send-data <owner-session-id>`
-
-Exports workflow artifacts and uploads them to the configured Supabase endpoint.
-
-```bash
-slopmachine send-data <owner-session-id>
-```
-
-Supported options:
-
-- `--dry-run`
-- `--yes`
-- `--label <text>`
-- `--project-id <id>`
-- `--output <path>`
-- `--endpoint <url>`
-
-Examples:
-
-```bash
-slopmachine send-data ses_abc123
-slopmachine send-data ses_abc123 --dry-run
-slopmachine send-data ses_abc123 --yes --label sprint-12
-slopmachine send-data ses_abc123 --endpoint "https://<project-ref>.supabase.co/functions/v1/slopmachine-upload"
-```
-
-Where to run it:
-
-- preferred: workspace root
-- also supported: `repo/`
-
-If run from `repo/`, the command resolves the parent workspace root automatically.
-
-What it exports live:
-
-- owner session from the positional `owner-session-id`
-- developer sessions from `.ai/metadata.json`
-- `beads-export.json` from root `.beads/`
-
-What it includes when present:
-
-- `.tmp/`
-- `retrospective-<run_id>.md`
-- `improvement-actions-<run_id>.md`
-- `test_coverage_and_readme_audit_report.md`
-
-What it always includes:
-
-- `metadata.json`
-- `ai-metadata.json`
-- `manifest.json`
-
-Fail-fast conditions:
-
-- missing owner session id argument
-- missing `.ai/metadata.json`
-- missing `run_id`
-- missing tracked developer session ids
-- owner session export failure
-- developer session export failure
-
-Warn-only conditions:
-
-- missing `.tmp/`
-- missing retrospective files
-
-Output behavior:
-
-- creates a flat zip archive
-- keeps the local zip by default
-- default zip path:
-  - `~/slopmachine/retrospectives/send-data-<run_id>.zip`
-- shows a preview before upload unless `--yes` is passed
+Use `slopmachine init` to create or adopt a task root. By default it seeds `AGENTS.md` for OpenCode developer lanes. Use `slopmachine init --claude` to seed `CLAUDE.md` and `.claude/` for script-managed Claude Code lanes. The unused rulebook is not left in the task folder, and `../.ai/metadata.json` records the active `developer_rulebook_file`.
 
-## Config Files
+## Phase Map
 
-Machine-level config:
+The owner workflow uses sequential phase names:
 
-- `~/.config/slopmachine/config.json`
+- Phase 1: Clarification
+- Phase 2: Planning
+- Phase 3: Development
+- Phase 4: Integrated Verification And Hardening
+- Phase 5: Evaluation And Fix Verification
+- Phase 6: Final Readiness Decision
+- Phase 7: Submission Packaging
+- Phase 8: Retrospective
 
-Current schema:
-
-```json
-{
-  "upload": {
-    "endpoint": "https://<project-ref>.supabase.co/functions/v1/slopmachine-upload",
-    "token": "sm_u_...",
-    "timeoutMs": 30000
-  }
-}
-```
-
-OpenCode config managed by setup:
-
-- `~/.config/opencode/opencode.json`
-
-Packaged MCPs managed by setup:
-
-- `context7`
-- `exa`
-
-## Installed Assets
-
-Agents:
-
-- `~/.config/opencode/agents/slopmachine.md`
-- `~/.config/opencode/agents/slopmachine-claude.md`
-- `~/.config/opencode/agents/developer.md`
-
-Skills:
-
-- installed under `~/.agents/skills/`
-
-Claude runtime assets:
-
-- `~/.claude/agents/developer.md`
-- `~/.claude/skills/frontend-design/`
-
-Workflow files:
-
-- installed under `~/slopmachine/`
-- includes `~/slopmachine/test-coverage-prompt.md`
+The CLI still accepts legacy start aliases where needed: `P1`, `P2`, `P3`, `P4`, `P5`, `P7`, `P8`, `P9`, and `P10`.
 
 ## Verification
 
-Package-level check:
-
-```bash
+```sh
+npm run typecheck
 npm run check
 ```
 
-Basic machine verification:
+`npm run check` runs the TypeScript check and verifies the CLI help path.
 
-```bash
-slopmachine --help
-slopmachine set-token
-slopmachine setup
-```
+## Package Contents
 
-`send-data` verification:
-
-```bash
-slopmachine send-data <owner-session-id> --dry-run --endpoint "https://<project-ref>.supabase.co/functions/v1/slopmachine-upload"
-```
+- `src/`: CLI implementation
+- `bin/`: executable entrypoint
+- `assets/agents/`: OpenCode agents
+- `assets/claude/`: Claude agents and Claude-specific skills
+- `assets/skills/`: shared owner skills
+- `assets/slopmachine/`: workflow prompts, templates, scaffold playbooks, and utility scripts
 
-## Notes
+## Developer-Facing Boundaries
 
-- the upload token is machine-level state and is not stored in the repo
-- the owner session id is currently supplied manually to `send-data`
-- developer session ids come from `.ai/metadata.json`
-- broad workflow files and session exports live at workspace root, not inside `repo/`
+Developer-facing prompts and rulebooks avoid owner workflow mechanics. They focus on good engineering practice: read the code, follow `AGENTS.md` or `CLAUDE.md`, implement real behavior, keep README claims honest, test meaningful behavior, avoid secrets, do not run Docker or `run_tests.sh` unless asked, and provide proof for completed work.

package/RELEASE.md

@@ -1,152 +1,10 @@
-# Release Guide
+# Release Notes
 
-## Local validation
+## v2 rebuild
 
-1. Run the CLI help:
-
-```bash
-node ./bin/slopmachine.js --help
-```
-
-2. Test install into an isolated fake home:
-
-```bash
-SLOPMACHINE_HOME="$(pwd)/.tmp-home" SLOPMACHINE_NONINTERACTIVE=1 SLOPMACHINE_PLUGIN_BOOTSTRAP=0 node ./bin/slopmachine.js setup
-```
-
-That setup path should install `opencode-ai` when OpenCode is missing and only refresh it when the detected version is below the minimum supported version.
-
-Users can later refresh to the newest published package with:
-
-```bash
-slopmachine upgrade
-```
-
-3. Test init into an isolated temp project:
-
-```bash
-mkdir -p .tmp-project
-SLOPMACHINE_HOME="$(pwd)/.tmp-home" node ./bin/slopmachine.js init .tmp-project
-```
-
-4. Test the open-after-bootstrap path:
-
-```bash
-mkdir -p .tmp-project-open
-SLOPMACHINE_HOME="$(pwd)/.tmp-home" node ./bin/slopmachine.js init -o .tmp-project-open
-```
-
-5. Test existing-project adoption bootstrap:
-
-```bash
-mkdir -p .tmp-project-adopt
-printf 'console.log("hello")\n' > .tmp-project-adopt/index.js
-SLOPMACHINE_HOME="$(pwd)/.tmp-home" node ./bin/slopmachine.js init --adopt --phase P3 .tmp-project-adopt
-```
-
-6. Test smoother existing-project bootstrap alias:
-
-```bash
-mkdir -p .tmp-project-continue
-printf 'console.log("hello")\n' > .tmp-project-continue/index.js
-SLOPMACHINE_HOME="$(pwd)/.tmp-home" node ./bin/slopmachine.js init --continue-from P3 .tmp-project-continue
-```
-
-7. Test `repo/` auto-wrap for `--continue-from`:
-
-```bash
-mkdir -p .tmp-project-continue-parent/repo
-printf 'console.log("hello")\n' > .tmp-project-continue-parent/repo/index.js
-(cd .tmp-project-continue-parent/repo && SLOPMACHINE_HOME="$(pwd)/../../.tmp-home" node ../../../bin/slopmachine.js init --continue-from P3)
-```
-
-Note:
-
-- `slopmachine init` is Node-driven.
-- Workflow bootstrap is driven through the packaged Node helper `workflow-init.js`.
-- before packing or publishing, make sure `git status --short` does not show junk artifacts such as `.DS_Store`, `__pycache__/`, or other accidental packaging noise
-
-## Pack the npm package
-
-```bash
-npm pack
-```
-
-This should produce a tarball named like:
-
-```bash
-theslopmachine-<version>.tgz
-```
-
-`<version>` comes from `package.json`, which is the single package-version source of truth.
-
-## Inspect package contents
-
-```bash
-tar -tzf theslopmachine-<version>.tgz
-```
-
-Check that the tarball includes:
-
-- `bin/`
-- `src/`
-- `assets/agents/`
-- `assets/skills/`
-- `assets/slopmachine/`
-- `README.md`
-- `RELEASE.md`
-
-And specifically verify that the tarball includes the current workflow assets:
-
-- `assets/agents/slopmachine.md`
-- `assets/agents/slopmachine-claude.md`
-- `assets/agents/developer.md`
-- `assets/claude/agents/developer.md`
-- `assets/skills/clarification-gate/`
-- `assets/skills/claude-worker-management/`
-- `assets/skills/planning-guidance/`
-- `assets/skills/submission-packaging/`
-- `assets/slopmachine/scaffold-playbooks/`
-- within `assets/slopmachine/scaffold-playbooks/`, verify the shared contract, family matrices, generic unknown-tech guide, and concrete verified/default playbooks are present for the currently supported scaffold families
-- `assets/slopmachine/templates/AGENTS.md`
-- `assets/slopmachine/templates/CLAUDE.md`
-- `assets/slopmachine/clarifier-agent-prompt.md`
-- `assets/slopmachine/phase-1-design-prompt.md`
-- `assets/slopmachine/phase-1-design-template.md`
-- `assets/slopmachine/phase-2-execution-planning-prompt.md`
-- `assets/slopmachine/owner-verification-checklist.md`
-- `assets/slopmachine/exact-readme-template.md`
-- `assets/slopmachine/workflow-init.js`
-- `assets/slopmachine/utils/cleanup_delivery_artifacts.py`
-- `assets/slopmachine/utils/package_claude_session.mjs`
-- `assets/slopmachine/utils/prepare_strict_audit_workspace.mjs`
-- `assets/slopmachine/utils/claude_wait_for_rate_limit_reset.mjs`
-- `assets/slopmachine/utils/claude_wait_for_rate_limit_reset.sh`
-- `assets/slopmachine/utils/claude_live_common.mjs`
-- `assets/slopmachine/utils/claude_live_launch.mjs`
-- `assets/slopmachine/utils/claude_live_turn.mjs`
-- `assets/slopmachine/utils/claude_live_status.mjs`
-- `assets/slopmachine/utils/claude_live_stop.mjs`
-- `assets/slopmachine/utils/run_with_timeout.mjs`
-- `assets/slopmachine/test-coverage-prompt.md`
-
-## Publish
-
-When ready to publish:
-
-```bash
-npm publish
-```
-
-If you want a dry run first:
-
-```bash
-npm publish --dry-run
-```
-
-## Versioning
-
-- `package.json` is the single package-version source of truth for the tarball name and CLI version banner
-- bump `package.json` version before each release
-- keep the CLI command as `slopmachine`
-- keep the npm package name as `theslopmachine`
+- Preserves the reference CLI/package behavior.
+- Rebuilds owner agents around Phase 1 through Phase 8 terminology.
+- Adds generic developer prompts for OpenCode and Claude.
+- Adds task-root `AGENTS.md` and `CLAUDE.md` templates focused on product engineering practice.
+- Includes Claude-specific worker skills and all required slopmachine utility scripts.
+- Keeps legacy `P*` phase aliases for CLI compatibility.