Prompt file imported from cstokes0091/META-COMPILER (.github/prompts/software-3.0-bootstrap.prompt.md). Copyright stays with the author.

Software 3.0 Bootstrap — Meta-Compiler as a Pure-Prompt Runtime

Name: software-3.0-bootstrap
Author: cstokes0091

Intent

Run the full meta-compiler pipeline end-to-end as a pure Software 3.0 program: the LLM is the runtime; this prompt is the program; workspace-artifacts/ is the heap. Given a problem statement and a seed directory, drive Stage 0 → Stage 4 (ingest, wiki v1/v2, decision log, implementation plan, workshop compile, execution, pitch) without invoking meta-compiler. One-shot helper scripts explicitly named below are allowed for extraction or inspection; the point is to remove the CLI as the bookkeeping runtime, not to ban every executable.

This prompt is a companion to software-3.0-conversion.prompt.md. The conversion prompt converts the existing Python+prompt system; this one expresses what the system DOES as a single prompt and lets the LLM execute it directly.

This is an intentional trade. You give up:

the schema validation in meta_compiler/validation.py
the citation/REQ ID minting in the CLI
the artifact path ownership in meta_compiler/artifacts.py
the seed-immutability enforcement in validate_seed_immutability
the non-overridable hook gating in .github/hooks/

You replace each with explicit checks the orchestrating LLM performs at each phase boundary, encoded in the §Determinism Replacements section below. Output reproducibility now equals LLM consistency — accept that fragility.

When (not) to use

Use this when: teaching the workflow without CLI overhead; probing what breaks when determinism is removed; lightweight one-shot bootstraps where durable artifacts aren't required.

Do NOT use this when: running production; needing REQ-NNN traceability across re-runs; requiring seed immutability across team handoffs; validating against schema before downstream consumers read artifacts. For any of those, run the Python CLI via the standard Stage 0–4 prompts.

Arguments

--problem-statement <path> (required) — markdown file describing the problem, goals, success criteria.
--seeds <dir> (default: <target>/seeds/) — source seed directory. If it is outside <target>/seeds/, mirror it into <target>/seeds/ before Stage 1A and treat the mirrored tree as immutable thereafter.
--target <dir> (default: ./workspace-artifacts/) — output root. Must match meta_compiler/artifacts.py::build_paths layout exactly.
--stage <id> — run a single stage (stage-0 … stage-4). Default: full pipeline.
--scope full|wiki-only|workshop-only — wiki-only stops after Stage 1A2 (wiki v2); workshop-only stops after Stage 3.

How this works

The repo's existing .github/prompts/stage-*.prompt.md files describe each stage as preflight CLI → orchestrator fan-out → postflight CLI. You execute the orchestrator fan-outs as written (they are already pure-LLM work) AND substitute equivalent reasoning for every CLI call, producing the same artifacts at the same paths with the same shapes.

Do not invent a new pipeline. The existing stage prompts are the canonical workflow source. This bootstrap prompt only tells you how to substitute the deterministic CLI half.

If .github/ prose and executable code disagree, prefer meta_compiler/cli.py and meta_compiler/stages/*.py as the current contract. Record the mismatch in your run notes instead of normalizing it away.

Anchor Texts (read first)

Same Software 3.0 framing as the conversion prompt — Karpathy's "Software Is Changing (Again)" (YC AI Startup School, June 2025). In particular hold these in mind:

Heterogeneous 1.0/3.0 is the right target. This prompt deliberately violates that to make the 3.0-only behaviour visible. Fragility is the point.
Generation-verification loops are how you stay honest without hooks: every artifact you write, you re-read in fresh attention to verify before moving on.
Build for agents. Every artifact you write must be machine-readable enough that a downstream LLM (or meta-compiler validate-stage, if anyone runs it later) can parse it without prose interpretation.

Inputs (read first, before Stage 0)

The user's --problem-statement file.
CLAUDE.md, LLM_INSTRUCTIONS.md, META-COMPILER.md — invariants and stage workflow.
meta_compiler/artifacts.py — canonical artifact paths. Every file you write must land at exactly the path build_paths would produce.
meta_compiler/validation.py — the schemas you must satisfy. Treat the validators as a spec for what you produce.
Every .github/prompts/stage-*.prompt.md and every relevant .github/agents/*.agent.md — the stage-specific reasoning lives here. Don't re-derive it.
.github/docs/hooks.md — the safety rails you are about to disable. Each named hook becomes a manual check you owe at the corresponding phase boundary.
--seeds directory listing.

CLI substitution table

For every meta-compiler X call referenced in a stage prompt, do the substitute action below. Write the same artifacts at the same paths.

CLI command	Pure-LLM substitute
`meta-init`	Create `<target>/` per `artifacts.py::build_paths`. If `--seeds` points elsewhere, mirror it into `<target>/seeds/` first and treat that mirrored tree as the tracked source of truth. Write `manifests/workspace_manifest.yaml` (project name, type, problem-statement hash, created-at). Provision `.github/agents,prompts,skills,instructions` if missing (copy from this repo or reference the canonical templates).
`ingest` (Stage 1A preflight)	Walk `<target>/seeds/`. Classify each path as `seed_kind: doc` or `code` (extension + bindings check). Write `runtime/ingest/work_plan.yaml` with `work_items[]` and `repo_map_items[]`. For binary docs, prefer an existing extracted text sidecar; otherwise use the repo's document-reading helpers as one-shot extraction aids. Mint `src-NNN` and `src-<repo>-<slug>` citation IDs deterministically (sorted seed list, monotonic counter).
`ingest-validate`	For each `wiki/findings/*.json` produced by the orchestrator fan-out, manually validate against the schema in `validation.py::validate_findings_file`. Reject and re-spawn the subagent on schema failure — do not silently coerce.
`research-breadth`	Aggregate `wiki/findings/*.json` into per-source pages (`wiki/pages/source-<id>.md`), per-concept pages (`concept-<slug>.md`), code-file pages (`code-<id>.md`), and code-repo pages (`code-repo-<name>.md`). Write `wiki/citations/index.yaml` with every claim's source id and locator.
`wiki-reconcile-concepts` / `wiki-apply-reconciliation`	Bucket `concepts[].name` across findings by normalized stem; spawn `concept-reconciler` subagents (max 4 parallel); persist returns to `runtime/wiki_reconcile/subagent_returns/{bucket}.json`; validate via `validate_concept_reconciliation_return`; promote canonical pages, merge `sources:`, append alias source notes, rewrite losers as `type: alias`. Stamp every write `source: concept_reconciliation`.
`wiki-cross-source-synthesize` / `wiki-apply-cross-source-synthesis`	For every canonical page with ≥2 source citations covered by ≥2 findings, fan out `cross-source-synthesizer`; persist returns; deterministically rewrite Definition / Key Claims / Open Questions while preserving frontmatter, H1, Formalism, Relationships, Source Notes. Write `wiki/reports/cross_source_synthesis_applied_v{N}.yaml`.
`wiki-link --version 2`	Index every canonical page's `aliases:` list and rewrite intra-wiki links so any mention of an alias resolves to the canonical page.
`research-depth`	Run the Schema Auditor / Adversarial Questioner / Domain Ontologist debate as written in `stage-1b-evaluators.prompt.md`; produce `wiki/reports/merged_gap_report.yaml`, the supporting evaluator reports, and the v2 sync artifacts the real CLI would emit.
`review`	Spawn three fresh-context reviewers (Optimistic / Pessimistic / Pragmatic). Each emits PROCEED or ITERATE with evidence. Loop 1B↔1C until all three PROCEED or the loop budget is hit; write both `wiki/reviews/review_verdicts.yaml` and `wiki/reviews/1a2_handoff.yaml` because Stage 2 consumes the handoff artifact.
`elicit-clarify --start`	Write `runtime/stage2/clarify/clarify_request.yaml`. Conduct the short clarification dialog from `stage-2-clarify.prompt.md`, then persist `runtime/stage2/clarify/clarify_response.yaml` with the request hash and duplicated top-level fields the topic extractor reads.
`wiki-search --scope stage2`	This is Stage 2 Step 0. Write `runtime/stage2/wiki_search/work_plan.yaml` and `runtime/stage2/wiki_search/wiki_search_request.yaml`. If fresh `results.yaml` already exists, return the cached path and proceed. Otherwise invoke `@wiki-search-orchestrator`, which writes one topic result file per work item under `runtime/stage2/wiki_search/results/`.
`wiki-search --apply`	Validate each per-topic YAML against the topic-result schema and consolidate the set into `runtime/stage2/wiki_search/results.yaml`. Only after this step should `elicit-vision --start` proceed to brief rendering.
`elicit-vision --start`	Require `runtime/stage2/clarify/clarify_response.yaml` and fresh Stage 2 wiki-search results unless you deliberately take the `--skip-wiki-search` escape hatch and record why. Render `runtime/stage2/brief.md`, `runtime/stage2/transcript.md`, and `runtime/stage2/precheck_request.yaml`.
`elicit-vision --finalize`	Parse `## Decision Block` sections from the completed transcript; mint `REQ-NNN` for behaviours and `CON-NNN` for constraints (carry `kind` + `verification_required`); write `decision-logs/decision_log_v{N}.yaml`.
`audit-requirements`	For every REQ/CON, verify the citing finding still exists in `wiki/findings/`; emit `decision-logs/requirements_audit.yaml` listing PASS / GAP / DRIFT entries.
`plan-implementation --start`	Render `runtime/plan/brief.md` from decision log + findings + citations, including planner evidence context, trigger vocabulary, and cited finding summaries.
`plan-implementation --finalize`	Validate the human-edited `decision-logs/implementation_plan_v{N}.md` has all six required sections and a `capability_plan` YAML fenced block; extract the YAML to `decision-logs/plan_extract_v{N}.yaml`.
`compile-capabilities`	Read decision log + plan extract (or fall back to 1-to-1 row mapping if absent) + cited findings; emit `scaffolds/v{N}/capabilities.yaml` with `when_to_use`, `required_finding_ids`, `requirement_ids`, `constraint_ids`, `verification_required`, and (if v2 plan extract) phase/objective/implementation_steps/acceptance_criteria/explicit_triggers/evidence_refs.
`extract-contracts`	Walk `agents_needed[]`, `architecture[]`, `code_architecture.data_model`; dedupe IO shapes; write one `contracts/{id}.yaml` per shape + `contracts/_manifest.yaml`; rewrite capabilities with real `io_contract_ref` values.
`synthesize-skills`	Render one `skills/{capability_name}/SKILL.md` per capability from cited findings only — no templated slots; render `skills/INDEX.md`. Pull concrete `implementation_steps` and `acceptance_criteria` from the plan extract when present.
`workspace-bootstrap`	Confirm the static repo-level execution palette (`implementer` / `reviewer` / `researcher` agents under `.github/agents/`) and preserve `implementation-planner` as the upstream planning surface. Write `EXECUTION_MANIFEST.yaml`, `DISPATCH_HINTS.yaml`, `SCAFFOLD_MANIFEST.yaml`, and `verification/REQ_TRACE.yaml` keyed by both REQ-NNN and CON-NNN. Emit one `verification/{hook_id}_spec.yaml` acceptance spec per `verification_required: true` capability (skip the others; record empty `hook_ids: []` in REQ_TRACE). Create empty output buckets per `project_types.scaffold_subdirs_for(project_type)`.
`phase4-finalize --finalize`	After the per-capability ralph loops produce fragments under `executions/v{N}/work/<cap>/`, compile `executions/v{N}/FINAL_OUTPUT_MANIFEST.yaml`; if `final/` exists, cite `assembled_deliverables[]` keyed by `ev-final-NNN`. Hand off to `@pitch-writer` to render `pitches/`.
`final-synthesize-start` / `--finalize`	Preflight: write `runtime/final_synthesis/work_plan.yaml` + `synthesis_request.yaml`. Fan out one synthesizer per modality (`@library-synthesizer` / `@document-synthesizer` / `@workflow-synthesizer`). Persist returns to `runtime/final_synthesis/subagent_returns/{modality}.json`. Postflight: validate each, run REQ-trace continuity check (every `REQ-NNN` mentioned in fragments must appear under `final/`, modulo `--allow-req-drop`), atomically swap `final/.tmp/` into place, emit `executions/v{N}/final_synthesis_report.yaml`.
`validate-stage --stage <N>`	Manually re-run the invariants for stage N from `validation.py`. Treat any failure as STOP — fix it before proceeding.

If you hit a CLI command not in this table, stop and ask the operator — don't improvise.

Workflow

For each stage, in order (or just the one named by --stage):

Read .github/prompts/stage-N-*.prompt.md end-to-end.
Execute the orchestrator fan-outs as written (they are already pure-LLM work — seed-reader, concept-reconciler, schema-auditor, etc., dispatched via the Agent tool).
For every meta-compiler X call the stage prompt would issue, do the substitute action from the table above. Write the same artifacts at the same paths in the same shape.
Run the §Determinism Replacement check for that phase boundary.
Stop and report the artifacts produced + the check results before moving to the next stage.

For Stage 2 specifically, preserve the real ordering: clarify → wiki-search preflight/orchestrator/apply → elicit-vision --start → dialog → elicit-vision --finalize → requirements audit. Only use the --skip-wiki-search escape hatch if you explicitly record why the cached or missing evidence is still acceptable.

If --scope wiki-only, stop after Stage 1A2. If --scope workshop-only, stop after Stage 3 (workspace-bootstrap).

Determinism replacements (manual checks the LLM must perform)

These are the hooks .github/docs/hooks.md would have run. With the Python CLI absent, you owe each check at the corresponding phase boundary. Do not skip any.

After Stage 0: Workspace tree exists per build_paths; manifest written; problem-statement hash recorded.
After Stage 0 seed mirroring: If --seeds pointed outside <target>/seeds/, the mirrored tree exists under <target>/seeds/, and all later stages read only from that tracked location.
After ingest preflight: Every seed appears in work_plan.yaml::work_items[]; every code-bound prefix has a repo_map_items[] entry; citation IDs are unique and monotonic.
After each seed-reader / code-reader / repo-mapper return: JSON validates against the matching schema; reject and re-spawn on failure.
After research-breadth: Every claim in wiki/pages/* has a citation id present in citations/index.yaml; every concept page lists ≥1 source.
After reconcile/cross-source apply: No canonical page lost its frontmatter, H1, Formalism, Relationships, or Source Notes; every alias page is type: alias and points to a real canonical.
After 1B↔1C loop: All three reviewers PROCEED, or the loop is explicitly bounded with a recorded reason. review_verdicts.yaml and 1a2_handoff.yaml both exist.
After Stage 2 clarify: runtime/stage2/clarify/clarify_response.yaml exists, its request_hash matches the request used, and the duplicated top-level fields are populated for the topic extractor.
After Stage 2 wiki-search apply: runtime/stage2/wiki_search/results.yaml exists or the freshness cache was explicitly hit; every topic in work_plan.yaml has either a valid per-topic result file or a recorded failure.
After elicit-vision finalize: Every REQ/CON id is unique; verification_required is set on every CON; every REQ cites ≥1 finding id.
After audit-requirements: Zero GAP entries (or recorded operator override).
After plan-implementation finalize: Markdown has all six sections; YAML extract round-trips; capability_plan ids are unique.
After workspace-bootstrap: REQ_TRACE.yaml lists every REQ and CON; every verification_required: true capability has a verification/{hook_id}_spec.yaml file; static palette agents exist.
After final-synthesize finalize: Every REQ-NNN mentioned in fragments under executions/v{N}/work/ appears in final/ (or is in --allow-req-drop); final/.tmp/ is gone.
Before declaring "done": git status shows no new edits outside <target>/ attributable to this run. Pre-existing unrelated changes may remain.

If any check fails, stop, report, and repair before continuing. Failed checks under this prompt are exactly the failures the hooks would have caught — they are not warnings.

Constraints (load-bearing — do not soften)

Preserve every rule in CLAUDE.md § Evidence Quality Rules: data over folklore, seed immutability, citation/requirement IDs survive transformations, findings JSON stays schema-valid, scaffold output drawn from cited findings only.
The repo-level implementation-planner agent remains the Stage 2.5 planning surface; Stage 4 itself binds only to the execution trio (implementer / reviewer / researcher). Do not invent domain-named scaffold agents.
Citation IDs and REQ/CON IDs are forever. Once minted, they do not renumber.
Do not modify files under <target>/seeds/ after they are tracked or mirrored there.
Do not create markdown docs outside the artifact tree unless explicitly requested.
If meta_compiler/ exists in this repo, do not edit it — this prompt's purpose is to operate WITHOUT it, not to replace it.

Postconditions

A run with --scope full produces the same artifact tree as a normal Python-driven run:

workspace-artifacts/ populated per artifacts.py::build_paths — manifests, seeds, wiki v1/v2, citations, findings, decision-logs (decision_log + audit + implementation_plan + plan_extract), scaffolds/v{N}/ (capabilities, contracts, skills, verification/{hook_id}_spec.yaml, REQ_TRACE.yaml, manifests, output buckets), executions/v{N}/ (work fragments + final/ + FINAL_OUTPUT_MANIFEST + final_synthesis_report), pitches/.
Every Determinism Replacement check passed at every phase boundary.
git status shows no new edits outside the artifact tree attributable to this run. Pre-existing unrelated changes may remain.
A second LLM, given only the artifacts and validation.py, can validate the run without reading this prompt's transcript.

If any Determinism Replacement check failed and was not repaired, the run did not succeed regardless of what artifacts exist on disk.

# Software 3.0 Bootstrap — Meta-Compiler as a Pure-Prompt Runtime ## Intent Run the full meta-compiler pipeline end-to-end as a pure Software 3.0 program: **the LLM is the runtime; this prompt is the program; `workspace-artifacts/` is the heap.** Given a problem statement and a seed directory, drive Stage 0 → Stage 4 (ingest, wiki v1/v2, decision log, implementation plan, workshop compile, execution, pitch) without invoking `meta-compiler`. One-shot helper scripts explicitly named below are allowed for extraction or inspection; the point is to remove the CLI as the bookkeeping runtime, not to ban every executable. This prompt is a **companion** to `software-3.0-conversion.prompt.md`. The conversion prompt converts the existing Python+prompt system; this one expresses what the system DOES as a single prompt and lets the LLM execute it directly. This is an **intentional trade**. You give up: - the schema validation in `meta_compiler/validation.py` - the citation/REQ ID minting in the CLI - the artifact path ownership in `meta_compiler/artifacts.py` - the seed-immutability enforcement in `validate_seed_immutability` - the non-overridable hook gating in `.github/hooks/` You replace each with **explicit checks the orchestrating LLM performs at each phase boundary**, encoded in the §Determinism Replacements section below. Output reproducibility now equals LLM consistency — accept that fragility. ## When (not) to use **Use this when:** teaching the workflow without CLI overhead; probing what breaks when determinism is removed; lightweight one-shot bootstraps where durable artifacts aren't required. **Do NOT use this when:** running production; needing REQ-NNN traceability across re-runs; requiring seed immutability across team handoffs; validating against schema before downstream consumers read artifacts. For any of those, run the Python CLI via the standard Stage 0–4 prompts. ## Arguments - `--problem-statement <path>` (**required**) — markdown file describing the problem, goals, success criteria. - `--seeds <dir>` (default: `<target>/seeds/`) — source seed directory. If it is outside `<target>/seeds/`, mirror it into `<target>/seeds/` before Stage 1A and treat the mirrored tree as immutable thereafter. - `--target <dir>` (default: `./workspace-artifacts/`) — output root. Must match `meta_compiler/artifacts.py::build_paths` layout exactly. - `--stage <id>` — run a single stage (`stage-0` … `stage-4`). Default: full pipeline. - `--scope full|wiki-only|workshop-only` — `wiki-only` stops after Stage 1A2 (wiki v2); `workshop-only` stops after Stage 3. ## How this works The repo's existing `.github/prompts/stage-*.prompt.md` files describe each stage as **preflight CLI → orchestrator fan-out → postflight CLI**. You execute the orchestrator fan-outs **as written** (they are already pure-LLM work) AND **substitute equivalent reasoning for every CLI call**, producing the same artifacts at the same paths with the same shapes. **Do not invent a new pipeline.** The existing stage prompts are the canonical workflow source. This bootstrap prompt only tells you how to substitute the deterministic CLI half. If `.github/` prose and executable code disagree, prefer `meta_compiler/cli.py` and `meta_compiler/stages/*.py` as the current contract. Record the mismatch in your run notes instead of normalizing it away. ## Anchor Texts (read first) Same Software 3.0 framing as the conversion prompt — Karpathy's *"Software Is Changing (Again)"* (YC AI Startup School, June 2025). In particular hold these in mind: - **Heterogeneous 1.0/3.0 is the right target.** This prompt deliberately violates that to make the 3.0-only behaviour visible. Fragility is the point. - **Generation-verification loops** are how you stay honest without hooks: every artifact you write, you re-read in fresh attention to verify before moving on. - **Build for agents.** Every artifact you write must be machine-readable enough that a downstream LLM (or `meta-compiler validate-stage`, if anyone runs it later) can parse it without prose interpretation. ## Inputs (read first, before Stage 0) 1. The user's `--problem-statement` file. 2. `CLAUDE.md`, `LLM_INSTRUCTIONS.md`, `META-COMPILER.md` — invariants and stage workflow. 3. `meta_compiler/artifacts.py` — **canonical artifact paths**. Every file you write must land at exactly the path `build_paths` would produce. 4. `meta_compiler/validation.py` — the schemas you must satisfy. Treat the validators as a spec for what you produce. 5. Every `.github/prompts/stage-*.prompt.md` and every relevant `.github/agents/*.agent.md` — the stage-specific reasoning lives here. Don't re-derive it. 6. `.github/docs/hooks.md` — the safety rails you are about to disable. Each named hook becomes a manual check you owe at the corresponding phase boundary. 7. `--seeds` directory listing. ## CLI substitution table For every `meta-compiler X` call referenced in a stage prompt, do the substitute action below. Write the same artifacts at the same paths. | CLI command | Pure-LLM substitute | |---|---| | `meta-init` | Create `<target>/` per `artifacts.py::build_paths`. If `--seeds` points elsewhere, mirror it into `<target>/seeds/` first and treat that mirrored tree as the tracked source of truth. Write `manifests/workspace_manifest.yaml` (project name, type, problem-statement hash, created-at). Provision `.github/agents,prompts,skills,instructions` if missing (copy from this repo or reference the canonical templates). | | `ingest` (Stage 1A preflight) | Walk `<target>/seeds/`. Classify each path as `seed_kind: doc` or `code` (extension + bindings check). Write `runtime/ingest/work_plan.yaml` with `work_items[]` and `repo_map_items[]`. For binary docs, prefer an existing extracted text sidecar; otherwise use the repo's document-reading helpers as one-shot extraction aids. Mint `src-NNN` and `src-<repo>-<slug>` citation IDs deterministically (sorted seed list, monotonic counter). | | `ingest-validate` | For each `wiki/findings/*.json` produced by the orchestrator fan-out, manually validate against the schema in `validation.py::validate_findings_file`. Reject and re-spawn the subagent on schema failure — do not silently coerce. | | `research-breadth` | Aggregate `wiki/findings/*.json` into per-source pages (`wiki/pages/source-<id>.md`), per-concept pages (`concept-<slug>.md`), code-file pages (`code-<id>.md`), and code-repo pages (`code-repo-<name>.md`). Write `wiki/citations/index.yaml` with every claim's source id and locator. | | `wiki-reconcile-concepts` / `wiki-apply-reconciliation` | Bucket `concepts[].name` across findings by normalized stem; spawn `concept-reconciler` subagents (max 4 parallel); persist returns to `runtime/wiki_reconcile/subagent_returns/{bucket}.json`; validate via `validate_concept_reconciliation_return`; promote canonical pages, merge `sources:`, append alias source notes, rewrite losers as `type: alias`. Stamp every write `source: concept_reconciliation`. | | `wiki-cross-source-synthesize` / `wiki-apply-cross-source-synthesis` | For every canonical page with ≥2 source citations covered by ≥2 findings, fan out `cross-source-synthesizer`; persist returns; deterministically rewrite Definition / Key Claims / Open Questions while preserving frontmatter, H1, Formalism, Relationships, Source Notes. Write `wiki/reports/cross_source_synthesis_applied_v{N}.yaml`. | | `wiki-link --version 2` | Index every canonical page's `aliases:` list and rewrite intra-wiki links so any mention of an alias resolves to the canonical page. | | `research-depth` | Run the Schema Auditor / Adversarial Questioner / Domain Ontologist debate as written in `stage-1b-evaluators.prompt.md`; produce `wiki/reports/merged_gap_report.yaml`, the supporting evaluator reports, and the v2 sync artifacts the real CLI would emit. | | `review` | Spawn three fresh-context reviewers (Optimistic / Pessimistic / Pragmatic). Each emits PROCEED or ITERATE with evidence. Loop 1B↔1C until all three PROCEED or the loop budget is hit; write both `wiki/reviews/review_verdicts.yaml` and `wiki/reviews/1a2_handoff.yaml` because Stage 2 consumes the handoff artifact. | | `elicit-clarify --start` | Write `runtime/stage2/clarify/clarify_request.yaml`. Conduct the short clarification dialog from `stage-2-clarify.prompt.md`, then persist `runtime/stage2/clarify/clarify_response.yaml` with the request hash and duplicated top-level fields the topic extractor reads. | | `wiki-search --scope stage2` | This is Stage 2 Step 0. Write `runtime/stage2/wiki_search/work_plan.yaml` and `runtime/stage2/wiki_search/wiki_search_request.yaml`. If fresh `results.yaml` already exists, return the cached path and proceed. Otherwise invoke `@wiki-search-orchestrator`, which writes one topic result file per work item under `runtime/stage2/wiki_search/results/`. | | `wiki-search --apply` | Validate each per-topic YAML against the topic-result schema and consolidate the set into `runtime/stage2/wiki_search/results.yaml`. Only after this step should `elicit-vision --start` proceed to brief rendering. | | `elicit-vision --start` | Require `runtime/stage2/clarify/clarify_response.yaml` and fresh Stage 2 wiki-search results unless you deliberately take the `--skip-wiki-search` escape hatch and record why. Render `runtime/stage2/brief.md`, `runtime/stage2/transcript.md`, and `runtime/stage2/precheck_request.yaml`. | | `elicit-vision --finalize` | Parse `## Decision Block` sections from the completed transcript; mint `REQ-NNN` for behaviours and `CON-NNN` for constraints (carry `kind` + `verification_required`); write `decision-logs/decision_log_v{N}.yaml`. | | `audit-requirements` | For every REQ/CON, verify the citing finding still exists in `wiki/findings/`; emit `decision-logs/requirements_audit.yaml` listing PASS / GAP / DRIFT entries. | | `plan-implementation --start` | Render `runtime/plan/brief.md` from decision log + findings + citations, including planner evidence context, trigger vocabulary, and cited finding summaries. | | `plan-implementation --finalize` | Validate the human-edited `decision-logs/implementation_plan_v{N}.md` has all six required sections and a `capability_plan` YAML fenced block; extract the YAML to `decision-logs/plan_extract_v{N}.yaml`. | | `compile-capabilities` | Read decision log + plan extract (or fall back to 1-to-1 row mapping if absent) + cited findings; emit `scaffolds/v{N}/capabilities.yaml` with `when_to_use`, `required_finding_ids`, `requirement_ids`, `constraint_ids`, `verification_required`, and (if v2 plan extract) phase/objective/implementation_steps/acceptance_criteria/explicit_triggers/evidence_refs. | | `extract-contracts` | Walk `agents_needed[]`, `architecture[]`, `code_architecture.data_model`; dedupe IO shapes; write one `contracts/{id}.yaml` per shape + `contracts/_manifest.yaml`; rewrite capabilities with real `io_contract_ref` values. | | `synthesize-skills` | Render one `skills/{capability_name}/SKILL.md` per capability **from cited findings only — no templated slots**; render `skills/INDEX.md`. Pull concrete `implementation_steps` and `acceptance_criteria` from the plan extract when present. | | `workspace-bootstrap` | Confirm the static repo-level execution palette (`implementer` / `reviewer` / `researcher` agents under `.github/agents/`) and preserve `implementation-planner` as the upstream planning surface. Write `EXECUTION_MANIFEST.yaml`, `DISPATCH_HINTS.yaml`, `SCAFFOLD_MANIFEST.yaml`, and `verification/REQ_TRACE.yaml` keyed by both REQ-NNN and CON-NNN. Emit one `verification/{hook_id}_spec.yaml` acceptance spec per `verification_required: true` capability (skip the others; record empty `hook_ids: []` in REQ_TRACE). Create empty output buckets per `project_types.scaffold_subdirs_for(project_type)`. | | `phase4-finalize --finalize` | After the per-capability ralph loops produce fragments under `executions/v{N}/work/<cap>/`, compile `executions/v{N}/FINAL_OUTPUT_MANIFEST.yaml`; if `final/` exists, cite `assembled_deliverables[]` keyed by `ev-final-NNN`. Hand off to `@pitch-writer` to render `pitches/`. | | `final-synthesize-start` / `--finalize` | Preflight: write `runtime/final_synthesis/work_plan.yaml` + `synthesis_request.yaml`. Fan out one synthesizer per modality (`@library-synthesizer` / `@document-synthesizer` / `@workflow-synthesizer`). Persist returns to `runtime/final_synthesis/subagent_returns/{modality}.json`. Postflight: validate each, run REQ-trace continuity check (every `REQ-NNN` mentioned in fragments must appear under `final/`, modulo `--allow-req-drop`), atomically swap `final/.tmp/` into place, emit `executions/v{N}/final_synthesis_report.yaml`. | | `validate-stage --stage <N>` | Manually re-run the invariants for stage N from `validation.py`. Treat any failure as STOP — fix it before proceeding. | If you hit a CLI command not in this table, **stop and ask the operator** — don't improvise. ## Workflow For each stage, in order (or just the one named by `--stage`): 1. **Read** `.github/prompts/stage-N-*.prompt.md` end-to-end. 2. **Execute the orchestrator fan-outs as written** (they are already pure-LLM work — `seed-reader`, `concept-reconciler`, `schema-auditor`, etc., dispatched via the Agent tool). 3. **For every `meta-compiler X` call** the stage prompt would issue, do the substitute action from the table above. Write the same artifacts at the same paths in the same shape. 4. **Run the §Determinism Replacement check** for that phase boundary. 5. **Stop and report** the artifacts produced + the check results before moving to the next stage. For Stage 2 specifically, preserve the real ordering: clarify → wiki-search preflight/orchestrator/apply → `elicit-vision --start` → dialog → `elicit-vision --finalize` → requirements audit. Only use the `--skip-wiki-search` escape hatch if you explicitly record why the cached or missing evidence is still acceptable. If `--scope wiki-only`, stop after Stage 1A2. If `--scope workshop-only`, stop after Stage 3 (workspace-bootstrap). ## Determinism replacements (manual checks the LLM must perform) These are the hooks `.github/docs/hooks.md` would have run. With the Python CLI absent, you owe each check at the corresponding phase boundary. **Do not skip any.** 1. **After Stage 0:** Workspace tree exists per `build_paths`; manifest written; problem-statement hash recorded. 2. **After Stage 0 seed mirroring:** If `--seeds` pointed outside `<target>/seeds/`, the mirrored tree exists under `<target>/seeds/`, and all later stages read only from that tracked location. 3. **After ingest preflight:** Every seed appears in `work_plan.yaml::work_items[]`; every code-bound prefix has a `repo_map_items[]` entry; citation IDs are unique and monotonic. 4. **After each `seed-reader` / `code-reader` / `repo-mapper` return:** JSON validates against the matching schema; reject and re-spawn on failure. 5. **After research-breadth:** Every claim in `wiki/pages/*` has a citation id present in `citations/index.yaml`; every concept page lists ≥1 source. 6. **After reconcile/cross-source apply:** No canonical page lost its frontmatter, H1, Formalism, Relationships, or Source Notes; every alias page is `type: alias` and points to a real canonical. 7. **After 1B↔1C loop:** All three reviewers PROCEED, or the loop is explicitly bounded with a recorded reason. `review_verdicts.yaml` and `1a2_handoff.yaml` both exist. 8. **After Stage 2 clarify:** `runtime/stage2/clarify/clarify_response.yaml` exists, its `request_hash` matches the request used, and the duplicated top-level fields are populated for the topic extractor. 9. **After Stage 2 wiki-search apply:** `runtime/stage2/wiki_search/results.yaml` exists or the freshness cache was explicitly hit; every topic in `work_plan.yaml` has either a valid per-topic result file or a recorded failure. 10. **After elicit-vision finalize:** Every REQ/CON id is unique; `verification_required` is set on every CON; every REQ cites ≥1 finding id. 11. **After audit-requirements:** Zero GAP entries (or recorded operator override). 12. **After plan-implementation finalize:** Markdown has all six sections; YAML extract round-trips; `capability_plan` ids are unique. 13. **After workspace-bootstrap:** `REQ_TRACE.yaml` lists every REQ and CON; every `verification_required: true` capability has a `verification/{hook_id}_spec.yaml` file; static palette agents exist. 14. **After final-synthesize finalize:** Every `REQ-NNN` mentioned in fragments under `executions/v{N}/work/` appears in `final/` (or is in `--allow-req-drop`); `final/.tmp/` is gone. 15. **Before declaring "done":** `git status` shows no new edits outside `<target>/` attributable to this run. Pre-existing unrelated changes may remain. If any check fails, **stop, report, and repair before continuing**. Failed checks under this prompt are exactly the failures the hooks would have caught — they are not warnings. ## Constraints (load-bearing — do not soften) - Preserve every rule in `CLAUDE.md` § Evidence Quality Rules: data over folklore, seed immutability, citation/requirement IDs survive transformations, findings JSON stays schema-valid, scaffold output drawn from cited findings only. - The repo-level `implementation-planner` agent remains the Stage 2.5 planning surface; Stage 4 itself binds only to the execution trio (`implementer` / `reviewer` / `researcher`). Do not invent domain-named scaffold agents. - Citation IDs and REQ/CON IDs are forever. Once minted, they do not renumber. - Do **not** modify files under `<target>/seeds/` after they are tracked or mirrored there. - Do **not** create markdown docs outside the artifact tree unless explicitly requested. - If `meta_compiler/` exists in this repo, **do not edit it** — this prompt's purpose is to operate WITHOUT it, not to replace it. ## Postconditions A run with `--scope full` produces the same artifact tree as a normal Python-driven run: - `workspace-artifacts/` populated per `artifacts.py::build_paths` — manifests, seeds, wiki v1/v2, citations, findings, decision-logs (decision_log + audit + implementation_plan + plan_extract), scaffolds/v{N}/ (capabilities, contracts, skills, `verification/{hook_id}_spec.yaml`, `REQ_TRACE.yaml`, manifests, output buckets), executions/v{N}/ (work fragments + final/ + FINAL_OUTPUT_MANIFEST + final_synthesis_report), pitches/. - Every Determinism Replacement check passed at every phase boundary. - `git status` shows no new edits outside the artifact tree attributable to this run. Pre-existing unrelated changes may remain. - A second LLM, given only the artifacts and `validation.py`, can validate the run without reading this prompt's transcript. If any Determinism Replacement check failed and was not repaired, **the run did not succeed** regardless of what artifacts exist on disk.

{ "prompt": "# Software 3.0 Bootstrap — Meta-Compiler as a Pure-Prompt Runtime\n\n## Intent\n\nRun the full meta-compiler pipeline end-to-end as a pure Software 3.0 program: **the LLM is the runtime; this prompt is the program; `workspace-artifacts/` is the heap.** Given a problem statement and a seed directory, drive Stage 0 → Stage 4 (ingest, wiki v1/v2, decision log, implementation plan, workshop compile, execution, pitch) without invoking `meta-compiler`. One-shot helper scripts explicitly named below are allowed for extraction or inspection; the point is to remove the CLI as the bookkeeping runtime, not to ban every executable.\n\nThis prompt is a **companion** to `software-3.0-conversion.prompt.md`. The conversion prompt converts the existing Python+prompt system; this one expresses what the system DOES as a single prompt and lets the LLM execute it directly.\n\nThis is an **intentional trade**. You give up:\n\n- the schema validation in `meta_compiler/validation.py`\n- the citation/REQ ID minting in the CLI\n- the artifact path ownership in `meta_compiler/artifacts.py`\n- the seed-immutability enforcement in `validate_seed_immutability`\n- the non-overridable hook gating in `.github/hooks/`\n\nYou replace each with **explicit checks the orchestrating LLM performs at each phase boundary**, encoded in the §Determinism Replacements section below. Output reproducibility now equals LLM consistency — accept that fragility.\n\n## When (not) to use\n\n**Use this when:** teaching the workflow without CLI overhead; probing what breaks when determinism is removed; lightweight one-shot bootstraps where durable artifacts aren't required.\n\n**Do NOT use this when:** running production; needing REQ-NNN traceability across re-runs; requiring seed immutability across team handoffs; validating against schema before downstream consumers read artifacts. For any of those, run the Python CLI via the standard Stage 0–4 prompts.\n\n## Arguments\n\n- `--problem-statement <path>` (**required**) — markdown file describing the problem, goals, success criteria.\n- `--seeds <dir>` (default: `<target>/seeds/`) — source seed directory. If it is outside `<target>/seeds/`, mirror it into `<target>/seeds/` before Stage 1A and treat the mirrored tree as immutable thereafter.\n- `--target <dir>` (default: `./workspace-artifacts/`) — output root. Must match `meta_compiler/artifacts.py::build_paths` layout exactly.\n- `--stage <id>` — run a single stage (`stage-0` … `stage-4`). Default: full pipeline.\n- `--scope full|wiki-only|workshop-only` — `wiki-only` stops after Stage 1A2 (wiki v2); `workshop-only` stops after Stage 3.\n\n## How this works\n\nThe repo's existing `.github/prompts/stage-*.prompt.md` files describe each stage as **preflight CLI → orchestrator fan-out → postflight CLI**. You execute the orchestrator fan-outs **as written** (they are already pure-LLM work) AND **substitute equivalent reasoning for every CLI call**, producing the same artifacts at the same paths with the same shapes.\n\n**Do not invent a new pipeline.** The existing stage prompts are the canonical workflow source. This bootstrap prompt only tells you how to substitute the deterministic CLI half.\n\nIf `.github/` prose and executable code disagree, prefer `meta_compiler/cli.py` and `meta_compiler/stages/*.py` as the current contract. Record the mismatch in your run notes instead of normalizing it away.\n\n## Anchor Texts (read first)\n\nSame Software 3.0 framing as the conversion prompt — Karpathy's *\"Software Is Changing (Again)\"* (YC AI Startup School, June 2025). In particular hold these in mind:\n\n- **Heterogeneous 1.0/3.0 is the right target.** This prompt deliberately violates that to make the 3.0-only behaviour visible. Fragility is the point.\n- **Generation-verification loops** are how you stay honest without hooks: every artifact you write, you re-read in fresh attention to verify before moving on.\n- **Build for agents.** Every artifact you write must be machine-readable enough that a downstream LLM (or `meta-compiler validate-stage`, if anyone runs it later) can parse it without prose interpretation.\n\n## Inputs (read first, before Stage 0)\n\n1. The user's `--problem-statement` file.\n2. `CLAUDE.md`, `LLM_INSTRUCTIONS.md`, `META-COMPILER.md` — invariants and stage workflow.\n3. `meta_compiler/artifacts.py` — **canonical artifact paths**. Every file you write must land at exactly the path `build_paths` would produce.\n4. `meta_compiler/validation.py` — the schemas you must satisfy. Treat the validators as a spec for what you produce.\n5. Every `.github/prompts/stage-*.prompt.md` and every relevant `.github/agents/*.agent.md` — the stage-specific reasoning lives here. Don't re-derive it.\n6. `.github/docs/hooks.md` — the safety rails you are about to disable. Each named hook becomes a manual check you owe at the corresponding phase boundary.\n7. `--seeds` directory listing.\n\n## CLI substitution table\n\nFor every `meta-compiler X` call referenced in a stage prompt, do the substitute action below. Write the same artifacts at the same paths.\n\n| CLI command | Pure-LLM substitute |\n|---|---|\n| `meta-init` | Create `<target>/` per `artifacts.py::build_paths`. If `--seeds` points elsewhere, mirror it into `<target>/seeds/` first and treat that mirrored tree as the tracked source of truth. Write `manifests/workspace_manifest.yaml` (project name, type, problem-statement hash, created-at). Provision `.github/agents,prompts,skills,instructions` if missing (copy from this repo or reference the canonical templates). |\n| `ingest` (Stage 1A preflight) | Walk `<target>/seeds/`. Classify each path as `seed_kind: doc` or `code` (extension + bindings check). Write `runtime/ingest/work_plan.yaml` with `work_items[]` and `repo_map_items[]`. For binary docs, prefer an existing extracted text sidecar; otherwise use the repo's document-reading helpers as one-shot extraction aids. Mint `src-NNN` and `src-<repo>-<slug>` citation IDs deterministically (sorted seed list, monotonic counter). |\n| `ingest-validate` | For each `wiki/findings/*.json` produced by the orchestrator fan-out, manually validate against the schema in `validation.py::validate_findings_file`. Reject and re-spawn the subagent on schema failure — do not silently coerce. |\n| `research-breadth` | Aggregate `wiki/findings/*.json` into per-source pages (`wiki/pages/source-<id>.md`), per-concept pages (`concept-<slug>.md`), code-file pages (`code-<id>.md`), and code-repo pages (`code-repo-<name>.md`). Write `wiki/citations/index.yaml` with every claim's source id and locator. |\n| `wiki-reconcile-concepts` / `wiki-apply-reconciliation` | Bucket `concepts[].name` across findings by normalized stem; spawn `concept-reconciler` subagents (max 4 parallel); persist returns to `runtime/wiki_reconcile/subagent_returns/{bucket}.json`; validate via `validate_concept_reconciliation_return`; promote canonical pages, merge `sources:`, append alias source notes, rewrite losers as `type: alias`. Stamp every write `source: concept_reconciliation`. |\n| `wiki-cross-source-synthesize` / `wiki-apply-cross-source-synthesis` | For every canonical page with ≥2 source citations covered by ≥2 findings, fan out `cross-source-synthesizer`; persist returns; deterministically rewrite Definition / Key Claims / Open Questions while preserving frontmatter, H1, Formalism, Relationships, Source Notes. Write `wiki/reports/cross_source_synthesis_applied_v{N}.yaml`. |\n| `wiki-link --version 2` | Index every canonical page's `aliases:` list and rewrite intra-wiki links so any mention of an alias resolves to the canonical page. |\n| `research-depth` | Run the Schema Auditor / Adversarial Questioner / Domain Ontologist debate as written in `stage-1b-evaluators.prompt.md`; produce `wiki/reports/merged_gap_report.yaml`, the supporting evaluator reports, and the v2 sync artifacts the real CLI would emit. |\n| `review` | Spawn three fresh-context reviewers (Optimistic / Pessimistic / Pragmatic). Each emits PROCEED or ITERATE with evidence. Loop 1B↔1C until all three PROCEED or the loop budget is hit; write both `wiki/reviews/review_verdicts.yaml` and `wiki/reviews/1a2_handoff.yaml` because Stage 2 consumes the handoff artifact. |\n| `elicit-clarify --start` | Write `runtime/stage2/clarify/clarify_request.yaml`. Conduct the short clarification dialog from `stage-2-clarify.prompt.md`, then persist `runtime/stage2/clarify/clarify_response.yaml` with the request hash and duplicated top-level fields the topic extractor reads. |\n| `wiki-search --scope stage2` | This is Stage 2 Step 0. Write `runtime/stage2/wiki_search/work_plan.yaml` and `runtime/stage2/wiki_search/wiki_search_request.yaml`. If fresh `results.yaml` already exists, return the cached path and proceed. Otherwise invoke `@wiki-search-orchestrator`, which writes one topic result file per work item under `runtime/stage2/wiki_search/results/`. |\n| `wiki-search --apply` | Validate each per-topic YAML against the topic-result schema and consolidate the set into `runtime/stage2/wiki_search/results.yaml`. Only after this step should `elicit-vision --start` proceed to brief rendering. |\n| `elicit-vision --start` | Require `runtime/stage2/clarify/clarify_response.yaml` and fresh Stage 2 wiki-search results unless you deliberately take the `--skip-wiki-search` escape hatch and record why. Render `runtime/stage2/brief.md`, `runtime/stage2/transcript.md`, and `runtime/stage2/precheck_request.yaml`. |\n| `elicit-vision --finalize` | Parse `## Decision Block` sections from the completed transcript; mint `REQ-NNN` for behaviours and `CON-NNN` for constraints (carry `kind` + `verification_required`); write `decision-logs/decision_log_v{N}.yaml`. |\n| `audit-requirements` | For every REQ/CON, verify the citing finding still exists in `wiki/findings/`; emit `decision-logs/requirements_audit.yaml` listing PASS / GAP / DRIFT entries. |\n| `plan-implementation --start` | Render `runtime/plan/brief.md` from decision log + findings + citations, including planner evidence context, trigger vocabulary, and cited finding summaries. |\n| `plan-implementation --finalize` | Validate the human-edited `decision-logs/implementation_plan_v{N}.md` has all six required sections and a `capability_plan` YAML fenced block; extract the YAML to `decision-logs/plan_extract_v{N}.yaml`. |\n| `compile-capabilities` | Read decision log + plan extract (or fall back to 1-to-1 row mapping if absent) + cited findings; emit `scaffolds/v{N}/capabilities.yaml` with `when_to_use`, `required_finding_ids`, `requirement_ids`, `constraint_ids`, `verification_required`, and (if v2 plan extract) phase/objective/implementation_steps/acceptance_criteria/explicit_triggers/evidence_refs. |\n| `extract-contracts` | Walk `agents_needed[]`, `architecture[]`, `code_architecture.data_model`; dedupe IO shapes; write one `contracts/{id}.yaml` per shape + `contracts/_manifest.yaml`; rewrite capabilities with real `io_contract_ref` values. |\n| `synthesize-skills` | Render one `skills/{capability_name}/SKILL.md` per capability **from cited findings only — no templated slots**; render `skills/INDEX.md`. Pull concrete `implementation_steps` and `acceptance_criteria` from the plan extract when present. |\n| `workspace-bootstrap` | Confirm the static repo-level execution palette (`implementer` / `reviewer` / `researcher` agents under `.github/agents/`) and preserve `implementation-planner` as the upstream planning surface. Write `EXECUTION_MANIFEST.yaml`, `DISPATCH_HINTS.yaml`, `SCAFFOLD_MANIFEST.yaml`, and `verification/REQ_TRACE.yaml` keyed by both REQ-NNN and CON-NNN. Emit one `verification/{hook_id}_spec.yaml` acceptance spec per `verification_required: true` capability (skip the others; record empty `hook_ids: []` in REQ_TRACE). Create empty output buckets per `project_types.scaffold_subdirs_for(project_type)`. |\n| `phase4-finalize --finalize` | After the per-capability ralph loops produce fragments under `executions/v{N}/work/<cap>/`, compile `executions/v{N}/FINAL_OUTPUT_MANIFEST.yaml`; if `final/` exists, cite `assembled_deliverables[]` keyed by `ev-final-NNN`. Hand off to `@pitch-writer` to render `pitches/`. |\n| `final-synthesize-start` / `--finalize` | Preflight: write `runtime/final_synthesis/work_plan.yaml` + `synthesis_request.yaml`. Fan out one synthesizer per modality (`@library-synthesizer` / `@document-synthesizer` / `@workflow-synthesizer`). Persist returns to `runtime/final_synthesis/subagent_returns/{modality}.json`. Postflight: validate each, run REQ-trace continuity check (every `REQ-NNN` mentioned in fragments must appear under `final/`, modulo `--allow-req-drop`), atomically swap `final/.tmp/` into place, emit `executions/v{N}/final_synthesis_report.yaml`. |\n| `validate-stage --stage <N>` | Manually re-run the invariants for stage N from `validation.py`. Treat any failure as STOP — fix it before proceeding. |\n\nIf you hit a CLI command not in this table, **stop and ask the operator** — don't improvise.\n\n## Workflow\n\nFor each stage, in order (or just the one named by `--stage`):\n\n1. **Read** `.github/prompts/stage-N-*.prompt.md` end-to-end.\n2. **Execute the orchestrator fan-outs as written** (they are already pure-LLM work — `seed-reader`, `concept-reconciler`, `schema-auditor`, etc., dispatched via the Agent tool).\n3. **For every `meta-compiler X` call** the stage prompt would issue, do the substitute action from the table above. Write the same artifacts at the same paths in the same shape.\n4. **Run the §Determinism Replacement check** for that phase boundary.\n5. **Stop and report** the artifacts produced + the check results before moving to the next stage.\n\nFor Stage 2 specifically, preserve the real ordering: clarify → wiki-search preflight/orchestrator/apply → `elicit-vision --start` → dialog → `elicit-vision --finalize` → requirements audit. Only use the `--skip-wiki-search` escape hatch if you explicitly record why the cached or missing evidence is still acceptable.\n\nIf `--scope wiki-only`, stop after Stage 1A2. If `--scope workshop-only`, stop after Stage 3 (workspace-bootstrap).\n\n## Determinism replacements (manual checks the LLM must perform)\n\nThese are the hooks `.github/docs/hooks.md` would have run. With the Python CLI absent, you owe each check at the corresponding phase boundary. **Do not skip any.**\n\n1. **After Stage 0:** Workspace tree exists per `build_paths`; manifest written; problem-statement hash recorded.\n2. **After Stage 0 seed mirroring:** If `--seeds` pointed outside `<target>/seeds/`, the mirrored tree exists under `<target>/seeds/`, and all later stages read only from that tracked location.\n3. **After ingest preflight:** Every seed appears in `work_plan.yaml::work_items[]`; every code-bound prefix has a `repo_map_items[]` entry; citation IDs are unique and monotonic.\n4. **After each `seed-reader` / `code-reader` / `repo-mapper` return:** JSON validates against the matching schema; reject and re-spawn on failure.\n5. **After research-breadth:** Every claim in `wiki/pages/*` has a citation id present in `citations/index.yaml`; every concept page lists ≥1 source.\n6. **After reconcile/cross-source apply:** No canonical page lost its frontmatter, H1, Formalism, Relationships, or Source Notes; every alias page is `type: alias` and points to a real canonical.\n7. **After 1B↔1C loop:** All three reviewers PROCEED, or the loop is explicitly bounded with a recorded reason. `review_verdicts.yaml` and `1a2_handoff.yaml` both exist.\n8. **After Stage 2 clarify:** `runtime/stage2/clarify/clarify_response.yaml` exists, its `request_hash` matches the request used, and the duplicated top-level fields are populated for the topic extractor.\n9. **After Stage 2 wiki-search apply:** `runtime/stage2/wiki_search/results.yaml` exists or the freshness cache was explicitly hit; every topic in `work_plan.yaml` has either a valid per-topic result file or a recorded failure.\n10. **After elicit-vision finalize:** Every REQ/CON id is unique; `verification_required` is set on every CON; every REQ cites ≥1 finding id.\n11. **After audit-requirements:** Zero GAP entries (or recorded operator override).\n12. **After plan-implementation finalize:** Markdown has all six sections; YAML extract round-trips; `capability_plan` ids are unique.\n13. **After workspace-bootstrap:** `REQ_TRACE.yaml` lists every REQ and CON; every `verification_required: true` capability has a `verification/{hook_id}_spec.yaml` file; static palette agents exist.\n14. **After final-synthesize finalize:** Every `REQ-NNN` mentioned in fragments under `executions/v{N}/work/` appears in `final/` (or is in `--allow-req-drop`); `final/.tmp/` is gone.\n15. **Before declaring \"done\":** `git status` shows no new edits outside `<target>/` attributable to this run. Pre-existing unrelated changes may remain.\n\nIf any check fails, **stop, report, and repair before continuing**. Failed checks under this prompt are exactly the failures the hooks would have caught — they are not warnings.\n\n## Constraints (load-bearing — do not soften)\n\n- Preserve every rule in `CLAUDE.md` § Evidence Quality Rules: data over folklore, seed immutability, citation/requirement IDs survive transformations, findings JSON stays schema-valid, scaffold output drawn from cited findings only.\n- The repo-level `implementation-planner` agent remains the Stage 2.5 planning surface; Stage 4 itself binds only to the execution trio (`implementer` / `reviewer` / `researcher`). Do not invent domain-named scaffold agents.\n- Citation IDs and REQ/CON IDs are forever. Once minted, they do not renumber.\n- Do **not** modify files under `<target>/seeds/` after they are tracked or mirrored there.\n- Do **not** create markdown docs outside the artifact tree unless explicitly requested.\n- If `meta_compiler/` exists in this repo, **do not edit it** — this prompt's purpose is to operate WITHOUT it, not to replace it.\n\n## Postconditions\n\nA run with `--scope full` produces the same artifact tree as a normal Python-driven run:\n\n- `workspace-artifacts/` populated per `artifacts.py::build_paths` — manifests, seeds, wiki v1/v2, citations, findings, decision-logs (decision_log + audit + implementation_plan + plan_extract), scaffolds/v{N}/ (capabilities, contracts, skills, `verification/{hook_id}_spec.yaml`, `REQ_TRACE.yaml`, manifests, output buckets), executions/v{N}/ (work fragments + final/ + FINAL_OUTPUT_MANIFEST + final_synthesis_report), pitches/.\n- Every Determinism Replacement check passed at every phase boundary.\n- `git status` shows no new edits outside the artifact tree attributable to this run. Pre-existing unrelated changes may remain.\n- A second LLM, given only the artifacts and `validation.py`, can validate the run without reading this prompt's transcript.\n\nIf any Determinism Replacement check failed and was not repaired, **the run did not succeed** regardless of what artifacts exist on disk.", "variables": [], "notes": "Bootstrap meta-compiler's full pipeline as a pure-prompt Software-3.0 runtime. Given a problem statement and seeds, the LLM drives ingest → wiki → decision log → workshop → execution → pitch end-to-end without invoking the Python CLI. Research/experimental — trades determinism for a pure-prompt expression of the workflow. Arguments: --problem-statement <path> [--seeds <dir>] [--target <dir>] [--stage stage-0|...|stage-4] [--scope full|wiki-only|workshop-only].", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/cstokes0091/META-COMPILER", "path": ".github/prompts/software-3.0-bootstrap.prompt.md", "ref": "dd3719f133ccf11bf033adfed1ad2f002eedb7bc", "url": "https://github.com/cstokes0091/META-COMPILER/blob/dd3719f133ccf11bf033adfed1ad2f002eedb7bc/.github/prompts/software-3.0-bootstrap.prompt.md", "key": "cstokes0091/META-COMPILER/.github/prompts/software-3.0-bootstrap.prompt.md" } }, "model_hints": [ "GPT-5.2 (copilot)" ] }

software-3.0-bootstrap

About