theslopmachine 1.0.22 → 1.0.24

package/MANUAL.md

@@ -15,30 +15,36 @@ The installer copies OpenCode agents to `~/.config/opencode/agents`, Claude asse
 ## Initialize A Task
 
 ```sh
-slopmachine init /path/to/task-root
+slopmachine init <github-url>
 ```
 
-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`.
+Run init from an empty workflow root. The GitHub repository name becomes the task root directory name. For example, `slopmachine init https://github.com/example/t178.git` clones into `./t178/`.
 
-Use `--claude` for `slopmachine-claude` runs:
+The cloned task root must already contain the task-facing structure: product code in `repo/`, product-facing docs in `docs/`, final kept reports in `.tmp/`, and project facts in `metadata.json`. SlopMachine creates workflow-private state in sibling `./.ai` and `./.beads` directories.
+
+Init relies on normal git authentication. If the repository is private and local git cannot access it, clone fails.
+
+SlopMachine no longer seeds developer-facing docs, API spec placeholders, product README content, `AGENTS.md`, or `.claude/settings.json`. It only writes the allowed task-root `CLAUDE.md` rulebook.
+
+Use `-o` to open OpenCode after bootstrap:
 
 ```sh
-slopmachine init --claude /path/to/task-root
+slopmachine init https://github.com/example/t178.git -o
 ```
 
-The active developer rulebook is recorded in `../.ai/metadata.json` as `developer_rulebook_file`. The unused rulebook is removed from the task folder.
+The active developer rulebook is recorded in `../.ai/metadata.json` as `developer_rulebook_file`.
 
 ## Continue From A Phase Alias
 
 ```sh
-slopmachine init --continue-from P5 /path/to/task-root
+slopmachine init <github-url> --continue-from P5
 ```
 
 Legacy aliases remain accepted for CLI compatibility, but owner-facing language uses Phase 1 through Phase 8.
 
 ## Developer Rulebooks
 
-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.
+Claude developer lanes read `CLAUDE.md`. SlopMachine seeds only this product engineering rulebook into the task root; it is not an owner workflow instruction file.
 
 ## Verification
 

package/README.md

@@ -27,12 +27,11 @@ slopmachine install
 ```sh
 slopmachine --help
 slopmachine install
-slopmachine init <target-dir>
-slopmachine init --claude <target-dir>
+slopmachine init <github-url>
 slopmachine set-token
 ```
 
-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`.
+Use `slopmachine init <github-url>` from an empty workflow root. The CLI clones the GitHub repository into `./<repo-name>/`, uses that cloned folder as the task root, creates workflow-private state under `./.ai` and `./.beads`, and records the repo name as `task_root` and `run_id`. The cloned task root is expected to contain the task-facing `docs/`, `.tmp/`, `metadata.json`, and `repo/` structure. SlopMachine no longer seeds developer-facing docs or product README content; it only writes the allowed task-root `CLAUDE.md` rulebook.
 
 ## Phase Map
 
@@ -69,4 +68,4 @@ npm run check
 
 ## Developer-Facing Boundaries
 
-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.
+Developer-facing prompts and the task-root `CLAUDE.md` rulebook avoid owner workflow mechanics. They focus on good engineering practice: read the code, 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

@@ -5,6 +5,6 @@
 - 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.
+- Seeds only the task-root `CLAUDE.md` rulebook; developer-facing docs and product README content come from the cloned task repository and implementation lane work.
 - Includes Claude-specific worker skills and all required slopmachine utility scripts.
 - Keeps legacy `P*` phase aliases for CLI compatibility.

package/assets/agents/slopmachine-claude.md

@@ -108,6 +108,8 @@ Good Claude-message style:
 
 ## Owner Direct Fixes And Developer Awareness
 
+The owner may directly make small safe edits to existing docs, config, wrappers, cleanup, and light glue when the change does not require product-design judgment, broad debugging, new product behavior, or new tests. Inside `./repo`, owner-side edits are limited to existing configuration, Docker files, test wrappers, run scripts, verification scripts, cleanup scripts, and similarly narrow glue. The owner must never create a new file anywhere under `./repo`. New product files, meaningful implementation work, new tests, behavioral changes, and larger fixes must go to the active Claude lane.
+
 When the owner makes direct edits to the task directory (README, config, scripts, docs, glue code, cleanup), the active Claude lane (develop-1, bugfix-1, or test-coverage-1) must always be informed of what changed. Batching is required: make a group of fixes, batch them together, then inform the lane once. Do not notify the lane turn by turn for every small edit.
 
 This rule applies strictly to the persistent implementation lanes — develop-1, bugfix-1, and test-coverage-1. It does not apply to evaluator sessions, clarification workers, faithfulness reviewers, planning subagents, or other temporary owner-side sessions.
@@ -148,7 +150,7 @@ Example: `I made a few edits to the README for the startup docs and fixed a conf
 - Never use `task` with `developer`, `implement`, `helper`, maintenance, or ad hoc coding subagents for product implementation, product bugfixes, product test authoring, product docs authored by the implementation lane, or implementation verification guidance. Those must go through live Claude lanes using the packaged Claude utilities.
 - Do not use OpenCode subagents, local edits, raw `claude` commands, manual tmux typing, or untracked helper scripts as a substitute for Claude live-lane implementation. The only normal interaction path with Claude lanes is `claude_live_launch.mjs`, `claude_live_turn.mjs`, `claude_live_status.mjs`, and `claude_live_stop.mjs`.
 - Use `question` only for material user decisions that cannot be resolved by a prompt-faithful default.
-- Use `edit`/`write` only for owner-side workflow files, reports, and tiny safe owner fixes that do not substitute for Claude implementation work. The owner may directly make small safe edits to docs, config, wrappers, cleanup, and light glue when the change does not require product-design judgment, broad debugging, new product behavior, or new tests. The owner must not create new files under `./repo`; new product files, meaningful implementation work, and larger fixes must go to the active Claude lane. Do not edit installed packaged prompt assets; those must always be read fresh and pasted verbatim under the non-negotiable verbatim prompt paste rule at the top of this file. If a tiny owner fix touches product code/docs, notify the active Claude lane and ask it to inspect/acknowledge before continuing.
+- Use `edit`/`write` only for owner-side workflow files, reports, and tiny safe owner fixes that do not substitute for Claude implementation work. Inside `./repo`, owner-side edits are limited to existing configuration, Docker files, test wrappers, run scripts, verification scripts, cleanup scripts, and similarly narrow glue. The owner must never create a new file anywhere under `./repo`; new product files, meaningful implementation work, new tests, behavioral changes, and larger fixes must go to the active Claude lane. Do not edit installed packaged prompt assets; those must always be read fresh and pasted verbatim under the non-negotiable verbatim prompt paste rule at the top of this file. If a tiny owner fix touches product code/docs, notify the active Claude lane and ask it to inspect/acknowledge before continuing.
 - Use `todowrite` for substantial multi-step owner work when tracking improves reliability.
 - Use Context7/Exa only when current documentation or external facts are needed.
 
@@ -228,7 +230,7 @@ Use these sequential names as the canonical workflow model. Legacy `P*` names ar
 
 - Required skills: `beads-operations`, `developer-session-lifecycle`, `claude-worker-management`, `planning-guidance`, `planning-gate`, `owner-evidence-discipline`, and `report-output-discipline` when reports are long or reusable.
 - Establish or resume the primary Claude lane and start design/planning.
-- Follow the deterministic planning sequence in `planning-guidance` exactly: (1) send original prompt with only "don't write code yet" appended, (2) after acknowledgement send clarifications, (3) after acknowledgement send the design prompt verbatim.
+- Follow the deterministic planning sequence in `planning-guidance` exactly: (1) send original prompt with only the required planning/placeholder sentences appended, (2) after acknowledgement send clarifications, (3) after acknowledgement send the design prompt verbatim.
 - Delegate owner-private `../.ai/plan.md` creation to a general owner-side subagent. Read the installed `~/slopmachine/phase-2-execution-planning-prompt.md` and `~/slopmachine/phase-2-plan-template.md` fresh. Paste both bodies verbatim into the subagent message.
 - Record lane/session and artifact decisions in metadata and Beads.
 - Exit only when `planning-gate` is satisfied.

package/assets/agents/slopmachine.md

@@ -108,7 +108,7 @@ Good worker-message style:
 
 ## Owner Direct Fixes And Developer Awareness
 
-The owner may directly make small safe edits to docs, config, wrappers, cleanup, and light glue when the change does not require product-design judgment, broad debugging, new product behavior, or new tests. The owner must not create new files under `./repo`; new product files, meaningful implementation work, and larger fixes must go to the active developer/bugfix/test-coverage lane.
+The owner may directly make small safe edits to existing docs, config, wrappers, cleanup, and light glue when the change does not require product-design judgment, broad debugging, new product behavior, or new tests. Inside `./repo`, owner-side edits are limited to existing configuration, Docker files, test wrappers, run scripts, verification scripts, cleanup scripts, and similarly narrow glue. The owner must never create a new file anywhere under `./repo`. New product files, meaningful implementation work, new tests, behavioral changes, and larger fixes must go to the active developer/bugfix/test-coverage lane.
 
 When the owner makes direct edits to the task directory (README, config, scripts, docs, glue code, cleanup), the active developer/bugfix/test-coverage lane must always be informed of what changed. Batching is required: make a group of fixes, batch them together, then inform the lane once. Do not notify the lane turn by turn for every small edit.
 
@@ -149,7 +149,7 @@ Example: `I made a few edits to the README for the startup docs and fixed a conf
 - Do not use `implement`, `helper`, maintenance, or extra ad hoc subagents for product implementation unless the user explicitly asks. Keep implementation in the tracked active developer session except for evaluator-isolated work or a recorded recovery/context reason.
 - Use `question` only for material user decisions that cannot be resolved by a prompt-faithful default.
 - Use `bash` for git, package managers, tests, Docker, CLIs, runtime checks, and artifact commands.
-- Use `edit`/`write` for owner-side workflow files, tiny safe fixes, and reports. Do not edit installed packaged prompt assets; those must always be read fresh and pasted verbatim under the non-negotiable verbatim prompt paste rule at the top of this file.
+- Use `edit`/`write` for owner-side workflow files, reports, and tiny safe edits to existing docs/config/wrappers/scripts/glue. Inside `./repo`, never use owner-side editing to create new files; new repo files must be created by the active developer/bugfix/test-coverage lane. Do not edit installed packaged prompt assets; those must always be read fresh and pasted verbatim under the non-negotiable verbatim prompt paste rule at the top of this file.
 - Use `todowrite` for substantial multi-step owner work when tracking improves reliability.
 - Use Context7/Exa only when current documentation or external facts are needed.
 
@@ -197,7 +197,7 @@ Use these sequential names as the canonical workflow model. Legacy `P*` names ar
 
 - Required skills: `beads-operations`, `developer-session-lifecycle`, `planning-guidance`, `planning-gate`, `owner-evidence-discipline`, and `report-output-discipline` when reports are long or reusable.
 - Establish or resume the primary developer session and start design/planning.
-- Follow the deterministic planning sequence in `planning-guidance` exactly: (1) send original prompt with only "don't write code yet" appended, (2) after acknowledgement send clarifications, (3) after acknowledgement send the design prompt verbatim.
+- Follow the deterministic planning sequence in `planning-guidance` exactly: (1) send original prompt with only the required planning/placeholder sentences appended, (2) after acknowledgement send clarifications, (3) after acknowledgement send the design prompt verbatim.
 - Delegate owner-private `../.ai/plan.md` creation to a general owner-side subagent. Read the installed `~/slopmachine/phase-2-execution-planning-prompt.md` and `~/slopmachine/phase-2-plan-template.md` fresh. Paste both bodies verbatim into the subagent message.
 - Record session and artifact decisions in metadata and Beads.
 - Exit only when `planning-gate` is satisfied.

package/assets/skills/deep-retrospective/run.py

@@ -272,7 +272,19 @@ def main():
     beads = read_beads(project_path)
     ai_data = read_ai_metadata(project_path)
     task_dir = project_path if os.path.isdir(os.path.join(project_path, "docs")) \
-               else os.path.join(project_path, "task")
+               else None
+    if not task_dir:
+        ai_meta = os.path.join(project_path, ".ai", "metadata.json")
+        if os.path.isfile(ai_meta):
+            with open(ai_meta) as f:
+                ai_data = json.load(f)
+            task_root_name = ai_data.get("task_root") if isinstance(ai_data, dict) else None
+            candidate = os.path.join(project_path, task_root_name)
+            if os.path.isdir(os.path.join(candidate, "docs")):
+                task_dir = candidate
+    if not task_dir:
+        print(f"  Warning: could not find task root at {project_path} (no docs/ and no .ai/metadata.json with task_root)")
+        task_dir = project_path
     task_docs = read_task_docs(task_dir)
     audit_reports = read_audit_reports(task_dir)
     print(f"  Beads: {len(beads)}, Audit reports: {len(audit_reports)}")

package/assets/skills/deep-retrospective/workflow-reference.md

@@ -238,3 +238,4 @@ Implementation must:
 10. **Module isolation:** Modules built in isolation with no cross-module integration tests proving data/behavior flow between them
 11. **Skipped evaluator passes:** Fewer than 5 internal evaluator passes run in Phase 4
 12. **No browser verification before P6:** Web/fullstack projects reach P6 without any browser verification, finding crashes that should have been caught in P3 or P4
+13. **Owner-created repo files:** Owner creates new files under repo/ instead of routing file creation through the active developer lane

package/assets/skills/developer-session-lifecycle/SKILL.md

@@ -12,7 +12,7 @@ Use this skill for startup preflight, session policy, metadata consistency, lane
 Sessions are the primary deliverable. An incomplete or corrupted session dataset invalidates the submission regardless of code quality. Every session must be preserved, continuous, and authentic.
 
 - Do not edit, rename, restructure, rewrite, clean, delete, or fabricate session files or trajectory records. They are immutable evidence.
-- Do not perform untracked implementation work. Developer/Claude implementation, debugging, and substantive product fixes must happen inside a tracked implementation session. Owner orchestration, verification commands, package checks, and tiny safe owner-side docs/config/wrapper/glue fixes are allowed when recorded in metadata/Beads and the active implementation lane is notified afterward.
+- Do not perform untracked implementation work. Developer/Claude implementation, debugging, and substantive product fixes must happen inside a tracked implementation session. Owner orchestration, verification commands, package checks, and tiny safe owner-side edits to existing docs/config/wrappers/scripts/glue are allowed when recorded in metadata/Beads and the active implementation lane is notified afterward. The owner must never create a new file anywhere under `./repo`; new repo files must be created by the active developer/Claude lane.
 - Sessions must progress strictly forward. Never return to a closed session. The lifecycle is:
   1. Development session → complete → stop/close
   2. Bugfix session → complete both audit cycles → close
@@ -23,7 +23,7 @@ Sessions are the primary deliverable. An incomplete or corrupted session dataset
 ## Preflight
 
 - Confirm cwd is task root `./`.
-- Confirm the current working directory is the task root (the directory containing `repo/`, `docs/`, and `metadata.json`). If the root is not `task/` or its equivalent, stop and reject: sessions must be started from the task root, not from inside `repo/` or any subdirectory.
+- Confirm the current working directory is the task root (the directory containing `repo/`, `docs/`, and `metadata.json`). If the root does not contain these expected paths, stop and reject: sessions must be started from the task root, not from inside `repo/` or any subdirectory.
 - Confirm product repo exists at `./repo`.
 - Confirm workflow-private root exists at `../.ai`, workflow state exists at `../.ai/metadata.json`, and Beads root exists at `../.beads` when initialized.
 - Confirm task docs are limited to `./docs/questions.md`, `./docs/design.md`, and `./docs/api-spec.md` when applicable.
@@ -48,7 +48,7 @@ Sessions are the primary deliverable. An incomplete or corrupted session dataset
 - Phase 5 uses fresh evaluator sessions for full audits. Evaluator-session reuse occurs in three cases: (1) fail-regeneration — same session receives only the regeneration prompt after fixes; (2) Partial Pass fix-check — same session verifies all scoped issues are fixed; (3) Pass-with-items fix-check — same session verifies all scoped recommendations are closed.
 - Audit Cycle 1 and Audit Cycle 2 fixes go through the dedicated bugfix lane. After both audit cycles complete, the bugfix lane is closed and a new test-coverage/final-reconciliation lane takes over for coverage/README remediation.
 - Phase 6 reconciliation uses the currently active developer/Claude lane for Docker, runtime, browser, account, `run_tests.sh`, coverage, README, and final readiness fixes unless a new lane is explicitly justified by context limits or isolation risk.
-- If the owner directly changes docs, wrappers, config, cleanup, or light glue, send the active lane a minimal acknowledgement request that names the changed surface and asks it to inspect/confirm before readiness continues.
+- If the owner directly changes existing docs, wrappers, config, cleanup, scripts, or light glue, send the active lane a minimal acknowledgement request that names the changed surface and asks it to inspect/confirm before readiness continues.
 
 ## Metadata Discipline
 

package/assets/skills/final-evaluation-orchestration/SKILL.md

@@ -58,7 +58,7 @@ No other full-audit or fail-regeneration prompt is allowed. In particular, the o
 
 If any deviation is found from either allowed prompt send, the current audit cycle is invalid. Archive every report or candidate report generated during that invalid cycle unchanged under `../.ai/archive/`, record the restart reason in metadata and Beads, then restart that audit cycle from a fresh evaluator session using the installed asset and exact saved send packet. Do not patch, rename, or reuse invalid-cycle reports as kept reports.
 
-Record the installed prompt asset path, prepared prompt path, exact send packet path, evaluator session id, and report path in metadata and Beads. Treat evaluator reports as immutable once written.
+Record the installed prompt asset path, prepared prompt path, exact send packet path, evaluator session id, and report path in metadata and Beads. Treat evaluator reports as immutable once written except for the narrow minor wording cleanup allowed by cycle validation below.
 
 ## Report Paths And Names
 
@@ -152,6 +152,8 @@ Run this procedure twice: once for Audit Cycle 1 and once for Audit Cycle 2.
 
 Before a cycle can close, validate the whole cycle as a hard gate. If any item fails, archive every candidate/kept/fix-check report produced in that cycle unchanged under `../.ai/archive/`, record the reason, and restart that audit cycle from a fresh evaluator session using the non-negotiable full-audit prompt block.
 
+Exception: if the only issue is minor wording that does not change findings, verdict, severity, evidence, scoped issue identity, fix status, or report meaning, the owner may patch that wording directly in the kept report or fix-check report instead of restarting the cycle. Record the exact wording cleanup, file path, and reason in metadata and Beads. Do not use this exception to alter verdicts, remove real findings, add missing fix evidence, repair a mismatched issue list, or hide a materially invalid regeneration/fix-check.
+
 Required for each cycle:
 - the installed evaluation prompt asset path is recorded and matches the project type;
 - the exact saved send packet path is recorded;
@@ -160,8 +162,10 @@ Required for each cycle:
 - the kept audit report exists at `./.tmp/audit_report-<N>.md`;
 - the kept audit report is rich and complete: at least 150 lines and not materially shallower than the installed prompt's required output structure;
 - the kept audit report includes the required verdict, scope/boundary, prompt/repository mapping, section review or blocker/high panel as applicable, issues/suggestions or explicit no-issue statement, security/data-risk review where applicable, and test/logging/coverage sections required by the installed prompt;
+- the kept audit report has no language that reveals or implies it is a regeneration, rerun, continuation, post-fix report, or comparison against an earlier audit. Forbidden examples include: `regenerated`, `regeneration`, `rerun`, `previous audit`, `previous report`, `prior audit`, `after fixes`, `after the fixes`, `fixed since`, `remaining`, `still`, `now fixed`, `resolved`, `no longer`, `left`, `updated verdict`, or equivalent wording that exposes audit history. If this language is only incidental wording and does not affect findings or meaning, patch it and record the cleanup. If the report is continuation-shaped, fix-oriented, or materially depends on prior audit history, archive and restart the cycle;
 - the cycle fix-check report exists at `./.tmp/audit_report-<N>-fix_check.md`;
 - the cycle fix-check report confirms every issue/recommendation/caveat/suggestion/action item/requested change from the kept audit report is fixed, or explicitly confirms the kept audit report had zero scoped items to close;
+- the scoped issue list in the fix-check exactly matches the scoped issue list from the corresponding kept audit report. Every kept-audit issue/recommendation/caveat/suggestion/action item/requested change must appear in the fix-check with a fixed status and evidence, and the fix-check must not silently drop, merge beyond recognition, rename into a different issue, or add unrelated new audit issues. If the lists do not match, the cycle is invalid and must restart unless the mismatch is only a harmless wording/label discrepancy that can be patched without changing issue identity, fix status, evidence, or meaning;
 - the fix-check report does not perform a broader new audit and does not use history-exposing comparison language.
 
 No audit cycle is complete without both `./.tmp/audit_report-<N>.md` and `./.tmp/audit_report-<N>-fix_check.md` passing this validation gate.

package/assets/skills/p8-readiness-reconciliation/SKILL.md

@@ -74,7 +74,7 @@ If any final runtime, test, browser, account, or platform check cannot run, read
 
 ## Owner Direct Fixes
 
-- The owner may directly fix only minor, safe docs, wrapper, config, cleanup, or light glue issues when the change does not require product-design judgment, new tests, behavioral changes, or non-trivial debugging.
+- The owner may directly fix only minor, safe existing docs, wrapper, config, cleanup, run-script, verification-script, or light glue issues when the change does not require product-design judgment, new tests, behavioral changes, or non-trivial debugging. The owner must never create a new file anywhere under `./repo`; any new repo file must be created by the active developer/Claude lane.
 - If the reconciliation issue is large enough to need real implementation work, meaningful test updates, runtime debugging, README/runtime restructuring, or product judgment, do not fix it owner-side. Send it to the currently active developer/Claude lane.
 - Batch multiple direct fixes into a group, then inform the lane once. Do not notify turn by turn for every small edit. After all fixes in the batch are complete, send a single note describing all changed surfaces and ask the lane to inspect and acknowledge.
 - The note should be concise and developer-facing, not a workflow report.

package/assets/skills/planning-guidance/SKILL.md

@@ -22,7 +22,7 @@ Phase 2 establishes the primary developer session and produces the accepted plan
 - Accepted `./docs/questions.md`.
 - Accepted `../.ai/requirements-breakdown.md`.
 - Accepted `../.ai/clarification-faithfulness-review.md`.
-- Packaged design prompt and design template.
+- Packaged design prompt.
 - Packaged execution planning prompt and plan template.
 
 ## Deterministic Planning Sequence (Must Follow Exactly)
@@ -31,10 +31,11 @@ This sequence is strict. Do not combine, reorder, skip, or batch these steps. Ea
 
 ### Step 1: Send Original Prompt
 
-Send the original product prompt from `./metadata.json` exactly as-is. No prefix, no introduction, no context, no clarifications. Append only this exact sentence at the end:
+Send the original product prompt from `./metadata.json` exactly as-is. No prefix, no introduction, no context, no clarifications. Append only these exact sentences at the end:
 
 ```
 Don't write code yet — we'll plan this first.
+This folder may contain placeholder docs or repo content from the starting skeleton; please inspect it and remove or replace unrelated placeholder material as we go.
 ```
 
 That is the entire message. Wait for the developer to acknowledge before proceeding.
@@ -53,7 +54,7 @@ Wait for the developer to acknowledge before proceeding.
 
 ### Step 3: Send Design Prompt
 
-After the developer acknowledges the clarifications, read the installed `~/slopmachine/phase-1-design-prompt.md` fresh from its asset path and paste its full body verbatim under the non-negotiable verbatim prompt paste rule. The design prompt references the context already provided in Steps 1 and 2 and the template already seeded at `./docs/design.md`. Do not paste the template file body — it is already in the workspace.
+After the developer acknowledges the clarifications, read the installed `~/slopmachine/phase-1-design-prompt.md` fresh from its asset path and paste its full body verbatim under the non-negotiable verbatim prompt paste rule. The design prompt references the context already provided in Steps 1 and 2 and tells the lane what design surfaces to cover because `./docs/design.md` may be missing or placeholder-only.
 
 The design must:
 - be a true product/system design, not an execution plan
@@ -72,7 +73,9 @@ Patch small wording/traceability issues directly when meaning is unchanged. Send
 
 ### Step 5: Create `./docs/api-spec.md` When Applicable
 
-Use the accepted design as input. Require exact endpoint/interface contracts where APIs exist. If no meaningful API exists, mark `./docs/api-spec.md` as not applicable with a short reason. Record the API spec artifact path and applicability decision in metadata and Beads.
+Use the accepted design as input. Require exact endpoint/interface contracts where APIs exist. If `./docs/api-spec.md` is missing or placeholder-only, the implementation lane must create or replace it. If no meaningful API exists, mark `./docs/api-spec.md` as not applicable with a short reason. Record the API spec artifact path and applicability decision in metadata and Beads.
+
+The API spec prompt must ask for, where applicable: endpoint/interface name, purpose, actor/consumer, method/path or call signature, auth and permission model, request fields, response fields, validation rules, success status/result, important error cases, persistence/side effects, frontend or job consumers, and required API/integration tests. Do not provide endpoint conclusions that the design has not established; ask the lane to derive exact contracts from the accepted design and codebase context.
 
 ### Step 6: Owner Reviews Design and API Spec Together
 

package/assets/skills/scaffold-guidance/SKILL.md

@@ -39,7 +39,13 @@ Use casual, direct language. Example:
 ```text
 Let's start with the scaffold. Set up the base project in ./repo for the stack described in docs/design.md. Keep this to the framework, runtime, tests, and README foundation with a minimal proof page or endpoint. Do not add product-specific business logic yet.
 
+The cloned folder may contain placeholder docs, README text, scripts, or config. Remove or replace unrelated placeholder content instead of preserving it.
+
 The scaffold needs a working docker-compose.yml with a profile-gated test service, a run_tests.sh that runs the full test suite through Docker, a separate stack-native local test harness for fast implementation-time checks, a unit_tests directory for unit tests, an API_tests directory for API and integration HTTP tests, and a README baseline with startup, access, verification, and test commands. Make sure the local harness is separate from the Docker test path. The local harness is for fast iteration. run_tests.sh is the broad dockerized verification wrapper for later.
+
+The README needs to be enough for a reviewer to run and verify the project later: project type near the top, what the repo delivers, stack, repo layout, primary startup/access command, legacy docker-compose compatibility string when Docker Compose is used, verification method, auth/demo credentials or "No authentication required", seeded data or empty-state note, mock/local/debug disclosures, known limitations, and the Dockerized ./run_tests.sh contract. Do not leave template placeholders in README.
+
+The run_tests.sh and Docker config must be real, not placeholders: run_tests.sh should execute the broad Docker-contained test path, docker-compose.yml should include the app services needed for runtime and a profile-gated test service, and the local test harness should remain separate for fast implementation-time checks.
 ```
 
 Adjust the exact wording to the project. Do not over-format the message.

package/assets/skills/submission-packaging/SKILL.md

@@ -11,8 +11,8 @@ Packaging is a final-delivery contract, not a reporting exercise. Do not close P
 
 ## Package Boundary
 
-- Package root is `task/`.
-- Product repo is `task/repo`.
+- Package root is the task root directory (named by the task-id from `../.ai/metadata.json`'s `task_root` field).
+- Product repo is `<task-root>/repo`.
 - Workflow-private state remains outside package under `../.ai`, `../.beads`, and `../claude-sessions.zip`.
 - Do not package workflow-private state as product files.
 - The final task-root package allowlist is `docs/`, `repo/`, `.tmp/`, `metadata.json`, plus explicit VCS/validation exceptions.
@@ -81,7 +81,7 @@ Do not run broad Docker prune commands that can affect unrelated projects.
 ## Session Export
 
 - Export tracked developer sessions before closing packaging.
-- Claude-backed lanes produce `../claude-sessions.zip` as a sibling handoff artifact, not as a product file under `task/`.
+- Claude-backed lanes produce `../claude-sessions.zip` as a sibling handoff artifact, not as a product file under the task root.
 - Use packaged session export utilities when available and preserve prompt-anchored session provenance.
 - Verify exported session content is anchored to the original prompt from `./metadata.json` strongly enough to support package lineage.
 - Do not manually edit, rewrite, fabricate, rename, clean, delete, or restructure raw session/trajectory files to make the package look cleaner. Only use packaged export/normalization utilities that preserve provenance.

package/assets/slopmachine/phase-1-design-prompt.md

@@ -1,6 +1,6 @@
 You are helping create the product/system design for a software project.
 
-The original prompt, stack and context, accepted clarifications, and accepted requirements have already been provided in the previous steps. The design template is already seeded at ./docs/design.md.
+The original prompt, stack and context, accepted clarifications, and accepted requirements have already been provided in the previous steps. The task root may contain placeholder docs from the cloned starting repository; inspect them, keep only relevant true information, and replace unrelated placeholder content.
 
 Your task is to write `./docs/design.md`.
 
@@ -10,6 +10,22 @@ This is planning/design work only. Do not write implementation code.
 
 Produce a design document that is faithful to the original prompt and accepted clarifications. The design should be specific enough to guide implementation, but it must not become a step-by-step execution checklist.
 
+## Expected Shape
+
+Use clear sections that cover these surfaces where applicable:
+- project overview: project type, delivery shape, business objective, success outcome, and stack summary
+- prompt and clarification alignment: accepted requirements, accepted clarifications, safe assumptions, and explicit non-goals that do not narrow the prompt
+- actors, roles, permissions, and the main user/system flows
+- module design: purpose, owned behavior, UI/API/job surfaces, data ownership, failure/security cases, and required test surfaces
+- data design: entities/objects, lifecycle rules, visibility, and access rules
+- UI or interaction design, or a brief not-applicable reason
+- API or interface design, including whether `./docs/api-spec.md` is required
+- security and privacy design: auth, authorization, object isolation, sensitive data, logging/redaction, debug/admin protection, file/path safety, and abuse prevention where relevant
+- runtime and configuration design: runtime model, configuration model, persistence, seed/demo data, external integrations, and README startup/access/auth expectations
+- verification strategy: unit, API/integration, E2E/platform, frontend component, frontend-to-backend, README/runtime, Docker, and known proof boundaries
+- API spec handoff: whether a separate API spec is required and which API/interface families it must cover
+- remaining design risks that still need a decision
+
 ## Required Design Qualities
 
 The design must:
@@ -39,6 +55,6 @@ The design should define what the system must be and how its major parts fit tog
 
 ## Output
 
-Write the completed design to `./docs/design.md` using the template already seeded at that path. If a section is not applicable, keep it brief and explain why.
+Write the completed design to `./docs/design.md`. If a placeholder file already exists there, replace unrelated placeholder content rather than preserving it. If a section is not applicable, keep it brief and explain why.
 
 If the project has meaningful APIs or interface contracts, say that `./docs/api-spec.md` should be completed next and summarize the API families that need specification.

package/assets/slopmachine/utils/README.md

@@ -13,7 +13,7 @@ The current type-check gate covers the Claude/session tooling family because the
 
 ## Path Model
 
-- `--task-root` means the workflow task root, usually `<workflow-root>/task`.
+- `--task-root` means the workflow task root directory (named by the task-id from `../.ai/metadata.json`'s `task_root` field).
 - Product code lives under `<task-root>/repo`.
 - Workflow-private state lives outside task root under `<workflow-root>/.ai` and `<workflow-root>/.beads`.
 - Claude project lookup uses the task root because Claude transcripts are keyed by the working directory used to launch Claude.
@@ -115,10 +115,10 @@ Required:
 - `--task-root <task-root>`
 
 Important options:
-- `--output <zip-path>` writes the zip to a custom path; default is `<task-root>/claude-sessions.zip`
+- `--output <zip-path>` writes the zip to a custom path; default is `<workflow-root>/claude-sessions.zip`
 - `--label <text>` adds reporting context
 
-The helper copies the Claude project/session directory as-is, removes `.DS_Store` files and top-level `.jsonl` transcripts under 25KB from the staged copy, zips the folder contents directly, and writes a single zip. It does not normalize or rewrite transcript files.
+The helper copies the Claude project/session directory as-is into a temp directory, removes `.DS_Store` files and top-level `.jsonl` transcripts under 25KB from the staged copy, zips the whole copied folder, and writes a single zip. It does not normalize or rewrite transcript files.
 
 ### `analyze_claude_project_dir.mjs`
 

package/assets/slopmachine/utils/package_claude_session.mjs

@@ -18,7 +18,7 @@ Required:
   --task-root <task-root>
 
 Options:
-  --output <zip-path>             Zip output path (default: <task-root>/claude-sessions.zip)
+  --output <zip-path>             Zip output path (default: <workflow-root>/claude-sessions.zip)
   --label <text>                 Optional package label for reporting
 `)
 }
@@ -168,7 +168,7 @@ try {
   }
 
   const sourceProjectDir = await resolveClaudeProjectDir(taskRoot)
-  const outputPath = argv.output ? path.resolve(argv.output) : path.join(taskRoot, 'claude-sessions.zip')
+  const outputPath = argv.output ? path.resolve(argv.output) : path.join(path.dirname(taskRoot), 'claude-sessions.zip')
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'slopmachine-claude-project-'))
   const packageRoot = path.join(tempRoot, path.basename(sourceProjectDir))
 
@@ -177,7 +177,7 @@ try {
     await removeDsStoreFiles(packageRoot)
     const tinyRootTranscriptsRemoved = await removeTinyRootTranscripts(packageRoot)
     const included = (await listFilesRecursive(packageRoot)).sort((left, right) => left.localeCompare(right))
-    await createZipArchive(packageRoot, outputPath)
+    await createZipArchive(tempRoot, outputPath)
 
     emitSuccess(path.basename(sourceProjectDir), {
       output: outputPath,
@@ -185,7 +185,7 @@ try {
       label: argv.label || null,
       included,
       tiny_root_transcripts_removed: tinyRootTranscriptsRemoved,
-      packaging_mode: 'raw_claude_project_dir',
+      packaging_mode: 'raw_claude_project_dir_folder',
     })
   } finally {
     await fs.rm(tempRoot, { recursive: true, force: true }).catch(() => {})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theslopmachine",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "SlopMachine installer and project bootstrap CLI",
   "license": "MIT",
   "type": "module",

package/src/cli.js

@@ -10,7 +10,7 @@ function printHelp() {
 Commands:
   setup     Configure slopmachine in the local user environment
   upgrade   Install slopmachine@latest globally and rerun setup
-  init      Bootstrap a workspace (--claude seeds CLAUDE.md, --opencode seeds AGENTS.md, --adopt wraps existing project, -o opens OpenCode)
+  init <github-url> Clone a task repository into the current workflow root and bootstrap workflow state (-o opens OpenCode)
   cleanup   Remove/archive obsolete installed agents, skills, and assets (--dry-run previews)
   set-token Store the upload token in machine config
   send-data Upload workflow artifacts to Supabase

package/src/constants.js

@@ -44,12 +44,10 @@ export const REQUIRED_SLOPMACHINE_FILES = [
   "clarifier-agent-prompt.md",
   "clarification-faithfulness-review-prompt.md",
   "phase-1-design-prompt.md",
-  "phase-1-design-template.md",
   "phase-2-execution-planning-prompt.md",
   "phase-2-plan-template.md",
   "test-coverage-prompt.md",
   "owner-verification-checklist.md",
-  "exact-readme-template.md",
   "workflow-init.js",
   "templates/AGENTS.md",
   "templates/CLAUDE.md",

package/src/init.js

@@ -1,111 +1,11 @@
-import fs from 'node:fs/promises'
-import { randomUUID } from 'node:crypto'
 import path from 'node:path'
+import fs from 'node:fs/promises'
 
 import { PACKAGE_ROOT, buildPaths } from './constants.js'
-import { ensureDir, log, pathExists, readJsonIfExists, resolveCommand, runCommand, warn, writeJson } from './utils.js'
-
-const GITIGNORE_ENTRIES = [
-  '# OS / editor noise',
-  '.DS_Store',
-  '**/.DS_Store',
-  'Thumbs.db',
-  '.idea/',
-  '.vscode/',
-  '*.swp',
-  '*.swo',
-  '*~',
-
-  '# Environment / secrets',
-  '.env',
-  '.env.*',
-  '!.env.example',
-  '*.pem',
-  '*.key',
-  '*.crt',
-
-  '# Logs',
-  '*.log',
-  'logs/',
-  'npm-debug.log*',
-  'yarn-debug.log*',
-  'yarn-error.log*',
-  'pnpm-debug.log*',
-  'gh-multi_logs/',
-  'antigravity-logs/',
-
-  '# Node / package managers',
-  'node_modules/',
-  '.npm/',
-  '.pnpm-store/',
-  '.yarn/cache/',
-  '.yarn/unplugged/',
-  '.yarn/build-state.yml',
-  '.yarn/install-state.gz',
-
-  '# Build / coverage outputs',
-  'dist/',
-  'build/',
-  'out/',
-  'coverage/',
-  '.coverage',
-  '.nyc_output/',
-  '.next/',
-  '.nuxt/',
-  '.output/',
-  '.vite/',
-  'storybook-static/',
-
-  '# Test / framework caches',
-  '.cache/',
-  '.parcel-cache/',
-  '.turbo/',
-  '.eslintcache',
-  '*.tsbuildinfo',
-  'playwright-report/',
-  'test-results/',
-  'blob-report/',
-
-  '# Python caches',
-  '.pytest_cache/',
-  '.mypy_cache/',
-  '.ruff_cache/',
-  '__pycache__/',
-  '**/__pycache__/',
-  '*.py[cod]',
-  '.venv/',
-  'venv/',
-
-  '# Archives / packaged outputs',
-  '*.tgz',
-  '*.tar.gz',
-  '*.zip',
-  '*.raw',
-
-  '# Local session/runtime artifacts',
-  'sessions/',
-  'claude-sessions.zip',
-  'session-export-*.raw',
-  '.tmp-*/',
-  '.tmp-home*/',
-  '.tmp-project*/',
-  '.tmp-fakebin/',
-  'sync-machine-assets.local.mjs',
-]
+import { ensureDir, log, pathExists, resolveCommand, runCommand, warn } from './utils.js'
 
 const ALLOWED_EXISTING_ENTRIES = new Set(['.DS_Store', '.git'])
-const INITIAL_COMMIT_PATHS = ['.gitignore', 'AGENTS.md', 'CLAUDE.md', '.claude', 'docs', 'metadata.json', 'repo']
-const ADOPTION_ROOT_KEEP = new Set([
-  '.DS_Store',
-  '.git',
-  '.gitignore',
-  '.ai',
-  '.beads',
-  'task',
-  'metadata.json',
-])
 const VALID_START_PHASES = new Set(['P1', 'P2', 'P3', 'P4', 'P5', 'P7', 'P8', 'P9', 'P10'])
-const VALID_PROJECT_TYPES = new Set(['backend', 'fullstack', 'web', 'android', 'ios', 'desktop'])
 const PHASE_LABELS = {
   P1: 'Phase 1 Clarification',
   P2: 'Phase 2 Planning',
@@ -155,11 +55,8 @@ async function resolveBrCommand(paths) {
 
 function parseInitArgs(args) {
   let openAfterInit = false
-  let adoptExisting = false
-  let continueFromExisting = false
-  let targetInput = '.'
+  let githubUrl = null
   let requestedStartPhase = null
-  let developerRulebookFile = null
 
   function setRequestedStartPhase(optionName, phase) {
     if (!VALID_START_PHASES.has(phase)) {
@@ -179,47 +76,22 @@ function parseInitArgs(args) {
       continue
     }
 
-    if (arg === '--adopt') {
-      adoptExisting = true
-      continue
-    }
-
     if (arg === '--claude') {
-      if (developerRulebookFile && developerRulebookFile !== 'CLAUDE.md') {
-        throw new Error('Conflicting developer rulebook options. Use only one of --claude, --opencode, or --rulebook.')
-      }
-      developerRulebookFile = 'CLAUDE.md'
+      // Claude is the only seeded developer rulebook now; keep this option as a harmless explicit mode.
       continue
     }
 
     if (arg === '--opencode') {
-      if (developerRulebookFile && developerRulebookFile !== 'AGENTS.md') {
-        throw new Error('Conflicting developer rulebook options. Use only one of --claude, --opencode, or --rulebook.')
-      }
-      developerRulebookFile = 'AGENTS.md'
+      throw new Error('--opencode is no longer supported for init. The cloned task root keeps only CLAUDE.md as the seeded developer rulebook.')
       continue
     }
 
     if (arg === '--rulebook') {
-      const nextArg = args[index + 1]
-      if (!nextArg) {
-        throw new Error('Missing value for --rulebook')
-      }
-      const normalizedRulebook = normalizeDeveloperRulebookOption(nextArg)
-      if (developerRulebookFile && developerRulebookFile !== normalizedRulebook) {
-        throw new Error('Conflicting developer rulebook options. Use only one of --claude, --opencode, or --rulebook.')
-      }
-      developerRulebookFile = normalizedRulebook
-      index += 1
-      continue
+      throw new Error('--rulebook is no longer supported for init. The cloned task root keeps only CLAUDE.md as the seeded developer rulebook.')
     }
 
     if (arg.startsWith('--rulebook=')) {
-      const normalizedRulebook = normalizeDeveloperRulebookOption(arg.slice('--rulebook='.length))
-      if (developerRulebookFile && developerRulebookFile !== normalizedRulebook) {
-        throw new Error('Conflicting developer rulebook options. Use only one of --claude, --opencode, or --rulebook.')
-      }
-      developerRulebookFile = normalizedRulebook
+      throw new Error('--rulebook is no longer supported for init. The cloned task root keeps only CLAUDE.md as the seeded developer rulebook.')
       continue
     }
 
@@ -244,16 +116,12 @@ function parseInitArgs(args) {
       if (!nextArg) {
         throw new Error('Missing value for --continue-from')
       }
-      adoptExisting = true
-      continueFromExisting = true
       setRequestedStartPhase('--continue-from', nextArg)
       index += 1
       continue
     }
 
     if (arg.startsWith('--continue-from=')) {
-      adoptExisting = true
-      continueFromExisting = true
       setRequestedStartPhase('--continue-from', arg.slice('--continue-from='.length))
       continue
     }
@@ -262,44 +130,24 @@ function parseInitArgs(args) {
       throw new Error(`Unknown init option: ${arg}`)
     }
 
-    targetInput = arg
+    if (!githubUrl) {
+      githubUrl = arg
+    } else {
+      throw new Error('slopmachine init accepts exactly one GitHub URL positional argument')
+    }
   }
 
-  return { openAfterInit, targetInput, adoptExisting, continueFromExisting, requestedStartPhase, developerRulebookFile: developerRulebookFile || 'AGENTS.md' }
-}
-
-function normalizeDeveloperRulebookOption(value) {
-  const normalized = String(value || '').trim().toLowerCase()
-  if (['agents', 'agent', 'opencode', 'agents.md'].includes(normalized)) {
-    return 'AGENTS.md'
+  if (!githubUrl) {
+    throw new Error('Usage: slopmachine init <github-url> [options]. The cloned repository name is used as the task root directory name.')
   }
-  if (['claude', 'claude.md'].includes(normalized)) {
-    return 'CLAUDE.md'
-  }
-  throw new Error("Unsupported --rulebook value. Use 'agents'/'opencode' or 'claude'.")
+
+  return { openAfterInit, githubUrl, requestedStartPhase, developerRulebookFile: 'CLAUDE.md' }
 }
 
 function normalizeRequestedStartPhase(phase) {
   return phase === 'P4' ? 'P3' : phase
 }
 
-function resolveWorkflowRootForInit(targetPath, options) {
-  if (!options.continueFromExisting) {
-    return targetPath
-  }
-
-  if (path.basename(targetPath) === 'task') {
-    return path.dirname(targetPath)
-  }
-
-  if (path.basename(targetPath) === 'repo') {
-    const parent = path.dirname(targetPath)
-    return path.basename(parent) === 'task' ? path.dirname(parent) : parent
-  }
-
-  return targetPath
-}
-
 async function assertRequiredFiles(paths) {
   const installedRoot = paths.slopmachineDir
   const packagedRoot = path.join(PACKAGE_ROOT, 'assets', 'slopmachine')
@@ -307,18 +155,12 @@ async function assertRequiredFiles(paths) {
   const installedFiles = {
     runtimeAssetRoot: installedRoot,
     trackerScript: path.join(installedRoot, 'workflow-init.js'),
-    agentsTemplate: path.join(installedRoot, 'templates', 'AGENTS.md'),
     claudeTemplate: path.join(installedRoot, 'templates', 'CLAUDE.md'),
-    phase1DesignTemplate: path.join(installedRoot, 'phase-1-design-template.md'),
-    readmeTemplate: path.join(installedRoot, 'exact-readme-template.md'),
   }
   const packagedFiles = {
     runtimeAssetRoot: packagedRoot,
     trackerScript: path.join(packagedRoot, 'workflow-init.js'),
-    agentsTemplate: path.join(packagedRoot, 'templates', 'AGENTS.md'),
     claudeTemplate: path.join(packagedRoot, 'templates', 'CLAUDE.md'),
-    phase1DesignTemplate: path.join(packagedRoot, 'phase-1-design-template.md'),
-    readmeTemplate: path.join(packagedRoot, 'exact-readme-template.md'),
   }
 
   const packagedReady = await Promise.all(Object.entries(packagedFiles)
@@ -341,14 +183,6 @@ async function assertRequiredFiles(paths) {
   )
 }
 
-async function resolveTarget(targetInput) {
-  const targetPath = path.resolve(process.cwd(), targetInput)
-  if (!(await pathExists(targetPath))) {
-    throw new Error(`Target directory '${targetInput}' does not exist or is not accessible.`)
-  }
-  return targetPath
-}
-
 async function assertBootstrapTargetIsEmpty(targetPath) {
   const entries = await fs.readdir(targetPath, { withFileTypes: true })
   const unexpectedEntries = entries
@@ -359,103 +193,56 @@ async function assertBootstrapTargetIsEmpty(targetPath) {
     return
   }
 
-  throw new Error(
-    `slopmachine init expects a new or empty target directory. Found existing entries: ${unexpectedEntries.join(', ')}`,
-  )
-}
-
-async function moveEntry(sourcePath, targetPath) {
-  try {
-    await fs.rename(sourcePath, targetPath)
-  } catch (error) {
-    if (error && error.code === 'EXDEV') {
-      await fs.cp(sourcePath, targetPath, { recursive: true, force: true })
-      await fs.rm(sourcePath, { recursive: true, force: true })
-      return
-    }
-    throw error
-  }
+    throw new Error(
+      `slopmachine init expects a new or empty workflow root. Found existing entries: ${unexpectedEntries.join(', ')}`,
+    )
 }
 
-async function prepareExistingProjectForAdoption(workflowRoot, taskRoot) {
-  await ensureDir(taskRoot)
-
-  const sourceGitDir = path.join(workflowRoot, '.git')
-  const taskGitDir = path.join(taskRoot, '.git')
-  if (await pathExists(sourceGitDir) && !(await pathExists(taskGitDir))) {
-    await moveEntry(sourceGitDir, taskGitDir)
+function deriveTaskIdFromGitHubUrl(githubUrl) {
+  const trimmed = String(githubUrl || '').trim()
+  if (!trimmed) {
+    throw new Error('Missing GitHub URL')
   }
 
-  const sourceMetadataPath = path.join(workflowRoot, 'metadata.json')
-  const taskMetadataPath = path.join(taskRoot, 'metadata.json')
-  if (await pathExists(sourceMetadataPath) && !(await pathExists(taskMetadataPath))) {
-    await moveEntry(sourceMetadataPath, taskMetadataPath)
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, '')
+  const lastPathPart = withoutTrailingSlash.split('/').pop()
+  const taskId = lastPathPart ? lastPathPart.replace(/\.git$/i, '') : ''
+  if (!taskId || taskId === '.' || taskId === '..') {
+    throw new Error(`Unable to derive task root directory name from GitHub URL: ${githubUrl}`)
   }
 
-  const entries = await fs.readdir(workflowRoot, { withFileTypes: true })
-  const namesToMove = entries
-    .map((entry) => entry.name)
-    .filter((name) => !ADOPTION_ROOT_KEEP.has(name))
-
-  if (namesToMove.length === 0) {
-    return { movedEntries: [], adoptedGitignore: false }
-  }
-
-  const repoPath = path.join(taskRoot, 'repo')
-  await ensureDir(repoPath)
-
-  let adoptedGitignore = false
-  const rootGitignorePath = path.join(workflowRoot, '.gitignore')
-  if (await pathExists(rootGitignorePath)) {
-    const repoGitignorePath = path.join(repoPath, '.gitignore')
-    if (!(await pathExists(repoGitignorePath))) {
-      await moveEntry(rootGitignorePath, repoGitignorePath)
-      adoptedGitignore = true
-    }
-  }
-
-  const movedEntries = []
-  for (const name of namesToMove) {
-    const sourcePath = path.join(workflowRoot, name)
-    const destinationPath = path.join(repoPath, name)
-    await moveEntry(sourcePath, destinationPath)
-    movedEntries.push(name)
-  }
-
-  return { movedEntries, adoptedGitignore }
+  return taskId
 }
 
-async function ensureGitRepo(targetPath) {
-  const repoCheck = await runCommand('git', ['-C', targetPath, 'rev-parse', '--is-inside-work-tree'])
-  if (repoCheck.code === 0) {
-    log('Git repository already initialized')
-    return
+async function cloneTaskRepository(githubUrl, taskRoot) {
+  if (await pathExists(taskRoot)) {
+    throw new Error(`Task root already exists: ${taskRoot}`)
   }
 
-  log('Initializing git repository')
-  const initResult = await runCommand('git', ['-C', targetPath, 'init'], { stdio: 'inherit' })
-  if (initResult.code !== 0) {
-    throw new Error('Git repository initialization failed')
+  log(`Cloning task repository into ${path.basename(taskRoot)}/`)
+  const result = await runCommand('git', ['clone', githubUrl, taskRoot], { stdio: 'inherit' })
+  if (result.code !== 0) {
+    throw new Error('Git clone failed. Check the GitHub URL and local git authentication, then retry.')
   }
 }
 
-async function ensureGitignore(targetPath) {
-  const gitignorePath = path.join(targetPath, '.gitignore')
-  await fs.writeFile(gitignorePath, '', { flag: 'a' })
-  const existingContent = await fs.readFile(gitignorePath, 'utf8')
-  const existingLines = new Set(existingContent.split(/\r?\n/))
-
-  const linesToAppend = []
-  for (const entry of GITIGNORE_ENTRIES) {
-    if (!existingLines.has(entry)) {
-      linesToAppend.push(entry)
-      log(`Added .gitignore entry: ${entry}`)
+async function assertClonedTaskStructure(taskRoot) {
+  const requiredPaths = [
+    'metadata.json',
+    'docs',
+    '.tmp',
+    'repo',
+  ]
+
+  const missing = []
+  for (const relativePath of requiredPaths) {
+    if (!(await pathExists(path.join(taskRoot, relativePath)))) {
+      missing.push(relativePath)
     }
   }
 
-  if (linesToAppend.length > 0) {
-    const prefix = existingContent.endsWith('\n') || existingContent.length === 0 ? '' : '\n'
-    await fs.appendFile(gitignorePath, `${prefix}${linesToAppend.join('\n')}\n`, 'utf8')
+  if (missing.length > 0) {
+    throw new Error(`Cloned task repository is missing required task-root paths: ${missing.join(', ')}`)
   }
 }
 
@@ -491,147 +278,47 @@ async function writeFileIfMissing(filePath, content) {
   return true
 }
 
-function normalizeProjectMetadataString(value) {
-  return typeof value === 'string' ? value : ''
-}
-
-function buildProjectMetadata(existingMetadata) {
-  const metadata = existingMetadata && typeof existingMetadata === 'object' && !Array.isArray(existingMetadata)
-    ? existingMetadata
-    : {}
-  const projectType = normalizeProjectMetadataString(metadata.project_type).trim().toLowerCase()
-
-  return {
-    prompt: normalizeProjectMetadataString(metadata.prompt),
-    project_type: VALID_PROJECT_TYPES.has(projectType) ? projectType : '',
-    frontend_language: normalizeProjectMetadataString(metadata.frontend_language),
-    backend_language: normalizeProjectMetadataString(metadata.backend_language),
-    database: normalizeProjectMetadataString(metadata.database),
-    frontend_framework: normalizeProjectMetadataString(metadata.frontend_framework),
-    backend_framework: normalizeProjectMetadataString(metadata.backend_framework),
-  }
-}
-
-function projectMetadataMatchesSchema(existingMetadata, normalizedMetadata) {
-  if (!existingMetadata || typeof existingMetadata !== 'object' || Array.isArray(existingMetadata)) {
-    return false
-  }
-
-  const expectedKeys = Object.keys(normalizedMetadata)
-  const existingKeys = Object.keys(existingMetadata)
-
-  return existingKeys.length === expectedKeys.length
-    && expectedKeys.every((key) => existingMetadata[key] === normalizedMetadata[key])
-}
-
-async function ensureProjectMetadata(projectMetadataPath) {
-  const existed = await pathExists(projectMetadataPath)
-  const existingMetadata = await readJsonIfExists(projectMetadataPath)
-  const normalizedMetadata = buildProjectMetadata(existingMetadata)
-
-  if (projectMetadataMatchesSchema(existingMetadata, normalizedMetadata)) {
-    return
-  }
-
-  log(existed ? 'Normalizing task metadata.json' : 'Creating task metadata.json')
-  await writeJson(projectMetadataPath, normalizedMetadata)
-}
-
-async function createInitialPhaseArtifacts(taskRoot, workflowRoot, runtimeAssetRoot, options) {
-  const questionsContent = `# Questions\n\n` +
-    `This file records only genuine original-prompt ambiguities that needed interpretation because they were unclear, incomplete, contradictory, or materially ambiguous.\n\n` +
-    `Use this structure for each real clarification item:\n\n` +
-    `### 1. <short clarification title>\n` +
-    `- Question: <the exact ambiguity or missing detail that needed to be locked>\n` +
-    `- My Understanding: <how the prompt was interpreted, why this was ambiguous, and why it matters>\n` +
-    `- Solution: <the chosen prompt-faithful resolution or safe default, written decisively>\n`
-  const designContent = await fs.readFile(
-    path.join(runtimeAssetRoot, 'phase-1-design-template.md'),
-    'utf8',
-  )
-
-  const apiSpecContent = `# API Spec\n\n` +
-    `Use this owner-maintained external document when API or interface contracts are material to the project.\n\n` +
-    `If the project has no meaningful API surface, mark this file as not applicable rather than deleting it silently.\n`
-
-  const repoReadmeContent = await fs.readFile(
-    path.join(runtimeAssetRoot, 'exact-readme-template.md'),
-    'utf8',
-  )
-
+async function createOwnerPrivateArtifacts(workflowRoot, options) {
   const startupContextContent = `# Startup Context\n\n` +
-    `- Bootstrap mode: ${options.adoptExisting ? 'adopt-existing-project' : 'new-workflow'}\n` +
+    `- Bootstrap mode: github-clone\n` +
     `${options.requestedStartPhase ? `- Requested start phase: ${options.requestedStartPhase}\n` : ''}` +
-    `${options.adoptExisting ? '- Catch up to the current repo state before trusting the requested phase. Only start from the requested phase if the codebase and evidence support it.\n' : '- Start from normal intake and clarification unless strong existing state already proves otherwise.\n'}` +
+    `- The cloned task root may contain placeholder developer-facing docs or repo content. The implementation lane should inspect and clear unrelated placeholders before relying on them.\n` +
     `- If the user sends a prompt block followed by appended stack/context lines, keep only the prompt block in ./metadata.json under prompt and record the appended stack/context lines separately here.\n`
 
-  await writeFileIfMissing(path.join(taskRoot, 'docs', 'questions.md'), questionsContent)
-  await writeFileIfMissing(path.join(taskRoot, 'docs', 'design.md'), designContent)
-  await writeFileIfMissing(path.join(taskRoot, 'docs', 'api-spec.md'), apiSpecContent)
   await writeFileIfMissing(path.join(workflowRoot, '.ai', 'startup-context.md'), startupContextContent)
   await writeFileIfMissing(path.join(workflowRoot, '.ai', 'plan.md'), '# Owner Private Plan\n\nThis owner-private plan is the internal execution checklist. Do not expose it to Claude as an instruction file; translate each slice into normal human prompts.\n')
   await writeFileIfMissing(path.join(workflowRoot, '.ai', 'requirements-breakdown.md'), '# Requirements Breakdown\n\nOwner-private requirement extraction goes here before design, API spec, or planning.\n')
   await writeFileIfMissing(path.join(workflowRoot, '.ai', 'test-coverage.md'), '# Test Coverage Plan\n\nOwner-private coverage planning and audit notes go here when applicable.\n')
-  await writeFileIfMissing(path.join(taskRoot, 'repo', 'README.md'), repoReadmeContent)
 }
 
-async function createRepoStructure(workflowRoot, taskRoot, runtimeAssetRoot, agentsTemplate, claudeTemplate, options) {
+async function createWorkflowStructure(workflowRoot, taskRoot, claudeTemplate, options) {
   const initialPhase = options.requestedStartPhase ? PHASE_LABELS[options.requestedStartPhase] : 'Phase 1 Clarification'
-  const developerRulebookFile = options.developerRulebookFile || 'AGENTS.md'
+  const developerRulebookFile = options.developerRulebookFile || 'CLAUDE.md'
+  const taskId = options.taskId
 
-  log('Creating task and workflow directories')
-  await ensureDir(path.join(taskRoot, '.tmp'))
-  await ensureDir(path.join(taskRoot, 'docs'))
+  log('Creating workflow directories')
   await ensureDir(path.join(workflowRoot, '.ai', 'claude-live'))
   await ensureDir(path.join(workflowRoot, '.ai', 'worktrees'))
 
-  log('Creating repo/ working directory')
-  await ensureDir(path.join(taskRoot, 'repo'))
-  const repoAgentsPath = path.join(taskRoot, 'AGENTS.md')
   const repoClaudePath = path.join(taskRoot, 'CLAUDE.md')
 
-  if (developerRulebookFile === 'AGENTS.md') {
-    log('Copying AGENTS template into task/')
-    if (await pathExists(repoAgentsPath)) {
-      await fs.copyFile(repoAgentsPath, path.join(workflowRoot, '.ai', 'original-task-AGENTS.md'))
-    }
-    await fs.copyFile(agentsTemplate, repoAgentsPath)
-    await fs.rm(repoClaudePath, { force: true })
-    await fs.rm(path.join(taskRoot, '.claude'), { recursive: true, force: true })
-  } else {
-    log('Copying CLAUDE template into task/')
-    if (await pathExists(repoClaudePath)) {
-      await fs.copyFile(repoClaudePath, path.join(workflowRoot, '.ai', 'original-task-CLAUDE.md'))
-    }
-    await fs.copyFile(claudeTemplate, repoClaudePath)
-    await fs.rm(repoAgentsPath, { force: true })
-    await ensureDir(path.join(taskRoot, '.claude'))
-    await writeFileIfMissing(
-      path.join(taskRoot, '.claude', 'settings.json'),
-      `${JSON.stringify({
-        $schema: 'https://json.schemastore.org/claude-code-settings.json',
-        agent: 'developer',
-        env: {
-          CLAUDE_CODE_SUBAGENT_MODEL: 'sonnet',
-        },
-      }, null, 2)}\n`,
-    )
+  log(`Copying CLAUDE template into ${taskId}/`)
+  if (await pathExists(repoClaudePath)) {
+    await fs.copyFile(repoClaudePath, path.join(workflowRoot, '.ai', 'original-task-CLAUDE.md'))
   }
-
-  const projectMetadataPath = path.join(taskRoot, 'metadata.json')
-  await ensureProjectMetadata(projectMetadataPath)
+  await fs.copyFile(claudeTemplate, repoClaudePath)
 
   const workflowMetadataPath = path.join(workflowRoot, '.ai', 'metadata.json')
   if (!(await pathExists(workflowMetadataPath))) {
       log('Creating .ai/metadata.json')
       await fs.writeFile(workflowMetadataPath, `${JSON.stringify({
-        run_id: randomUUID(),
+        run_id: taskId,
         current_phase: initialPhase,
         awaiting_human: false,
         evaluation_prompt_kind: null,
         active_evaluator_session_id: null,
-        task_root: 'task',
-        evaluation_reports_root: 'task/.tmp',
+        task_root: taskId,
+        evaluation_reports_root: `${taskId}/.tmp`,
         developer_sessions: [],
         developer_rulebook_file: developerRulebookFile,
         current_developer_lane: null,
@@ -642,40 +329,13 @@ async function createRepoStructure(workflowRoot, taskRoot, runtimeAssetRoot, age
         next_bugfix_session_number: 1,
         packaging_completed: false,
         claude_live_root: '.ai/claude-live',
-        bootstrap_mode: options.adoptExisting ? 'adopt' : 'new',
+        bootstrap_mode: 'github-clone',
+        github_url: options.githubUrl,
         requested_start_phase: options.requestedStartPhase,
       }, null, 2)}\n`, 'utf8')
   }
 
-  await createInitialPhaseArtifacts(taskRoot, workflowRoot, runtimeAssetRoot, options)
-}
-
-async function createInitialCommit(targetPath) {
-  log('Creating initial git checkpoint')
-  const existingInitialCommitPaths = []
-  for (const relativePath of INITIAL_COMMIT_PATHS) {
-    if (await pathExists(path.join(targetPath, relativePath))) {
-      existingInitialCommitPaths.push(relativePath)
-    }
-  }
-  const addResult = await runCommand('git', ['-C', targetPath, 'add', '--', ...existingInitialCommitPaths], { stdio: 'inherit' })
-  if (addResult.code !== 0) {
-    throw new Error('Initial git add failed')
-  }
-
-  const commitResult = await runCommand('git', ['-C', targetPath, 'commit', '-m', 'init'], { stdio: 'inherit' })
-  if (commitResult.code !== 0) {
-    throw new Error('Initial git commit failed. Configure git user.name/user.email or inspect repository state and retry.')
-  }
-
-  const statusResult = await runCommand('git', ['-C', targetPath, 'status', '--short'])
-  if (statusResult.code !== 0) {
-    throw new Error('Unable to verify the git worktree after bootstrap commit.')
-  }
-
-  if (statusResult.stdout.trim()) {
-    throw new Error(`Bootstrap left the repository dirty after the initial commit:\n${statusResult.stdout.trim()}`)
-  }
+  await createOwnerPrivateArtifacts(workflowRoot, options)
 }
 
 async function maybeOpenOpencode(taskRoot, openAfterInit) {
@@ -683,7 +343,9 @@ async function maybeOpenOpencode(taskRoot, openAfterInit) {
     return
   }
 
-  log('Opening OpenCode in task/')
+  const taskDirName = path.basename(taskRoot)
+
+  log(`Opening OpenCode in ${taskDirName}/`)
   let result
 
   if (process.platform === 'win32') {
@@ -697,7 +359,7 @@ async function maybeOpenOpencode(taskRoot, openAfterInit) {
       : await resolveCommand('zsh') || await resolveCommand('bash') || await resolveCommand('sh')
 
     if (!shellPath) {
-      warn('No usable shell was found to launch OpenCode automatically. Launch OpenCode manually inside task/.')
+      warn(`No usable shell was found to launch OpenCode automatically. Launch OpenCode manually inside ${taskDirName}/.`)
       return
     }
 
@@ -708,7 +370,7 @@ async function maybeOpenOpencode(taskRoot, openAfterInit) {
   }
 
   if (result.code !== 0) {
-    warn(`Failed to launch OpenCode automatically (${result.stderr || `exit code ${result.code}`}). Launch it manually inside task/.`)
+    warn(`Failed to launch OpenCode automatically (${result.stderr || `exit code ${result.code}`}). Launch it manually inside ${taskDirName}/.`)
   }
 }
 
@@ -716,53 +378,27 @@ export async function runInit(args = []) {
   assertSupportedPlatform()
 
   const paths = buildPaths()
-  const { openAfterInit, targetInput, adoptExisting, continueFromExisting, requestedStartPhase: rawRequestedStartPhase, developerRulebookFile } = parseInitArgs(args)
+  const { openAfterInit, githubUrl, requestedStartPhase: rawRequestedStartPhase, developerRulebookFile } = parseInitArgs(args)
   const requestedStartPhase = normalizeRequestedStartPhase(rawRequestedStartPhase)
-  if (requestedStartPhase && requestedStartPhase !== 'P1' && !adoptExisting && !continueFromExisting) {
-    throw new Error(`Later start phase '${requestedStartPhase}' requires --adopt or --continue-from because later-phase entry is only valid for existing-project recovery.`)
-  }
 
-  const { runtimeAssetRoot, trackerScript, agentsTemplate, claudeTemplate } = await assertRequiredFiles(paths)
-  const initialTargetPath = await resolveTarget(targetInput)
-  const workflowRoot = resolveWorkflowRootForInit(initialTargetPath, { continueFromExisting, targetInput })
-  const taskRoot = path.join(workflowRoot, 'task')
+  const { trackerScript, claudeTemplate } = await assertRequiredFiles(paths)
+  const workflowRoot = process.cwd()
+  const taskId = deriveTaskIdFromGitHubUrl(githubUrl)
+  const taskRoot = path.join(workflowRoot, taskId)
 
+  log(`Task id: ${taskId}`)
+  log(`GitHub URL: ${githubUrl}`)
   log(`Workflow root: ${workflowRoot}`)
   log(`Task root: ${taskRoot}`)
 
-  if (workflowRoot !== initialTargetPath) {
-    log(`Detected existing task/repo working directory at ${initialTargetPath}; using ${workflowRoot} as the workflow root`)
-  }
-
-  if (adoptExisting) {
-    const adoptionSummary = await prepareExistingProjectForAdoption(workflowRoot, taskRoot)
-    if (adoptionSummary.movedEntries.length > 0) {
-      log(`Adopted existing project into repo/: ${adoptionSummary.movedEntries.join(', ')}`)
-    } else {
-      log('Adoption mode enabled: no project files needed to be moved into repo/')
-    }
-    if (adoptionSummary.adoptedGitignore) {
-      log('Moved the existing project .gitignore into repo/.gitignore')
-    }
-  } else {
-    await assertBootstrapTargetIsEmpty(workflowRoot)
-  }
+  await assertBootstrapTargetIsEmpty(workflowRoot)
+  await cloneTaskRepository(githubUrl, taskRoot)
+  await assertClonedTaskStructure(taskRoot)
 
   log('Ensuring .ai/artifacts exists')
   await ensureDir(path.join(workflowRoot, '.ai', 'artifacts'))
-  await ensureDir(taskRoot)
-
-  await ensureGitRepo(taskRoot)
-  log('Ensuring .gitignore defaults')
-  await ensureGitignore(taskRoot)
   await runWorkflowBootstrap(paths, workflowRoot, trackerScript, { requestedStartPhase })
-  await createRepoStructure(workflowRoot, taskRoot, runtimeAssetRoot, agentsTemplate, claudeTemplate, { adoptExisting, requestedStartPhase, developerRulebookFile })
-
-  if (!adoptExisting) {
-    await createInitialCommit(taskRoot)
-  } else {
-    log('Skipping automatic bootstrap commit because this workspace adopted an existing project')
-  }
+  await createWorkflowStructure(workflowRoot, taskRoot, claudeTemplate, { githubUrl, requestedStartPhase, developerRulebookFile, taskId })
 
   await maybeOpenOpencode(taskRoot, openAfterInit)
 

package/src/install.js

@@ -150,7 +150,6 @@ async function writeOpencodeConfig(filePath, value) {
 const LEGACY_SUFFIX_PATTERN = /-(v2|v3)(\.md)?$/
 const OBSOLETE_PACKAGE_ASSET_FILES = [
   '01-phase-1-design-prompt.md',
-  '02-phase-1-design-template.md',
   '03-phase-2-execution-planning-prompt.md',
   '04-phase-2-plan-template.md',
   '06-owner-verification-checklist.md',
@@ -1532,7 +1531,7 @@ export async function runInstall() {
   console.log('\nNext steps')
   console.log('- Review any warnings above for skipped files or missing external dependencies.')
   console.log('- If Docker was reported as stopped, start Docker before using theslopmachine on a real project.')
-  console.log('- Run `slopmachine init` inside a project directory to bootstrap a new theslopmachine workspace.')
+  console.log('- Run `slopmachine init <github-url>` inside an empty workflow root to clone and bootstrap a task workspace.')
 }
 
 export async function runCleanup(args = []) {

package/src/send-data.js

@@ -119,12 +119,18 @@ async function resolveWorkflowPaths() {
     }
   }
 
-  const taskDir = path.join(cwd, 'task')
-  if (await pathExists(path.join(taskDir, 'metadata.json')) && await pathExists(path.join(cwd, '.ai', 'metadata.json'))) {
-    return { workflowRoot: cwd, taskRoot: taskDir, repoPath: path.join(taskDir, 'repo') }
+  const cwdWorkflowMetadata = path.join(cwd, '.ai', 'metadata.json')
+  if (await pathExists(cwdWorkflowMetadata)) {
+    const workflowMetadata = await readJsonIfExists(cwdWorkflowMetadata)
+    if (workflowMetadata && typeof workflowMetadata.task_root === 'string') {
+      const taskDir = path.join(cwd, workflowMetadata.task_root)
+      if (await pathExists(path.join(taskDir, 'metadata.json'))) {
+        return { workflowRoot: cwd, taskRoot: taskDir, repoPath: path.join(taskDir, 'repo') }
+      }
+    }
   }
 
-  throw new Error('slopmachine send-data must be run from task/, task/repo/, or the workflow root containing task/')
+  throw new Error('slopmachine send-data could not find the task root. Run from a task root directory (containing metadata.json and repo/), or from a workflow root (containing .ai/metadata.json).')
 }
 
 async function loadWorkflowMetadata(workflowRoot) {