theslopmachine 1.0.5 → 1.0.7

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 `task/` 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 workflow-root `.ai/` workflow files plus `.ai/artifacts`
-- creates hidden workflow-root `.ai/worktrees/` as the default location for parallel git worktrees
-- creates `task/` and initializes git inside `task/`
-- updates `task/.gitignore`
-- bootstraps beads_rust (`br`)
-- creates workflow-root `.beads/` outside `task/`
-- creates task-root `docs/`, `.tmp/`, `metadata.json`, and `repo/`
-- copies the packaged default rulebook into `task/AGENTS.md`
-- copies the packaged Claude rulebook into `task/CLAUDE.md`
-- seeds `task/repo/README.md`, task-visible product docs, and `task/.claude/settings.json`
-- seeds `.ai/startup-context.md` plus owner-private planning files under `.ai/`
-- keeps execution planning owner-private in `.ai/plan.md`
-- creates the initial git commit so the workspace starts with a clean tree
-- optionally opens `opencode` in `task/`
-- parallel worktrees should stay under hidden workflow-root `.ai/worktrees/` so the visible task root stays clean
-
-## Rough workflow
-
-1. Intake and setup
-2. Clarification
-3. Planning
-4. Development, starting with scaffold and then module-by-module owner prompts
-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 `./repo/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 `./repo/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 covers current packaged type, technology, and composed-stack playbooks under `~/slopmachine/scaffold-playbooks/`; unsupported stacks fall back to the generic scaffold path instead of a nonexistent named playbook.
-- 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,342 +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:
+`slopmachine install` installs bundled agents, Claude assets, shared skills, slopmachine prompt assets, utility scripts, and MCP config entries under the current user home.
 
-- shared runtime/test contract
-- stack selection matrix
-- type playbooks for web SPA, API service, database, background jobs, offline/local-first, Android, and desktop work
-- technology playbooks for React, Vue, Go, Koa, Laravel, Gin/Templ, MySQL, Postgres, Room, LocalDB, and Rust workspaces
-- composed stack playbooks for browser-only offline SPA, Vue/Koa/MySQL, Vue/Laravel/MySQL, React/Go/Postgres, Go/Gin/Templ/Postgres, Rust fullstack workspace, Android Room offline, WinForms LocalDB, and generic fallback work
-
-These playbooks are baseline-only references. The workflow uses them to guide the scaffold step from owner-private planning before module-by-module implementation continues.
-
-## Development Checks
-
-Run these before packaging changes to the CLI or installed tools:
-
-```bash
-npm run typecheck
-npm run check
-```
-
-`npm run typecheck` uses TypeScript `checkJs` over the package CLI source and shipped `assets/slopmachine` JavaScript utilities without adding a build step. The utility reference lives at `assets/slopmachine/utils/README.md` and documents each installed helper's arguments and output contract.
-
-### `slopmachine init`
-
-Use this in a new or empty project directory to create a SlopMachine workspace.
-
-```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:
-
-- workflow root `.ai/metadata.json`
-- workflow root `.ai/startup-context.md`
-- hidden workflow root `.ai/worktrees/` for parallel git worktrees when used
-- workflow root `.beads/`
-- `task/`
-- `task/.git/`
-- `task/AGENTS.md`
-- `task/CLAUDE.md`
-- `task/.claude/settings.json`
-- `task/repo/`
-- `task/repo/README.md`
-- `task/docs/questions.md`
-- `task/docs/design.md`
-- `task/docs/api-spec.md`
-- `task/.tmp/`
-- `task/metadata.json`
-
-Important details:
-
-- `run_id` is created in workflow root `.ai/metadata.json`
-- the operational session root is `task/`
-- product code lives under `task/repo/`
-- task-root `.tmp/` is the audit and fix-check artifact directory used during `P7`
-- task-root `.tmp/` also holds `test_coverage_and_readme_audit_report.md` after the final post-bugfix audit
-- task-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 workflow root outside `task/`
-- `task/.claude/settings.json` seeds Claude Code to use the custom `developer` agent by default for that task root
-- planned parallel git worktrees should live under hidden workflow root `.ai/worktrees/` by default so visible task-root folders do not clutter the delivery structure
-- owner-private execution planning lives under workflow root `.ai/plan.md` and is translated into normal developer prompts
-- after non-`-o` bootstrap, the command prints the exact `cd task` next step so you can continue immediately
-- `--adopt` moves the current project files into `task/repo/`, preserves workflow state outside `task/`, 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 `task/` or `task/repo/`, SlopMachine automatically resolves the surrounding workflow root instead of creating nested task/repo directories
-- 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
-- `task/docs/plan.md` and `task/docs/test-coverage.md` are not seeded or required; planning and coverage notes stay owner-private under workflow root `.ai/`
-
-### `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:
+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`.
 
-- 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
+## Phase Map
 
-### `slopmachine send-data <owner-session-id>`
+The owner workflow uses sequential phase names:
 
-Exports workflow artifacts and uploads them to the configured Supabase endpoint.
+- 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
 
-```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: `task/`
-- also supported: workflow root containing `task/`
-- also supported: `task/repo/`
-
-If run from `task/repo/`, the command resolves the surrounding task and workflow roots automatically.
-
-What it exports live:
-
-- owner session from the positional `owner-session-id`
-- developer sessions from workflow-root `.ai/metadata.json`
-- `beads-export.json` from workflow-root `.beads/`
-
-What it includes when present:
-
-- task-root `.tmp/`
-- `retrospective-<run_id>.md`
-- `improvement-actions-<run_id>.md`
-- `test_coverage_and_readme_audit_report.md`
-
-What it always includes:
-
-- task-root `metadata.json`
-- `ai-metadata.json`
-- `manifest.json`
-
-Fail-fast conditions:
-
-- missing owner session id argument
-- missing workflow-root `.ai/metadata.json`
-- missing `run_id`
-- missing tracked developer session ids
-- owner session export failure
-- developer session export failure
-
-Warn-only conditions:
-
-- missing task-root `.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
-
-## Config Files
-
-Machine-level config:
-
-- `~/.config/slopmachine/config.json`
-
-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 workflow-root `.ai/metadata.json`
-- broad workflow files and session exports live at workflow root, outside `task/`
+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 `task/repo/` auto-wrap for `--continue-from`:
-
-```bash
-mkdir -p .tmp-project-continue-parent/task/repo
-printf 'console.log("hello")\n' > .tmp-project-continue-parent/task/repo/index.js
-(cd .tmp-project-continue-parent/task/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.