Skip to content
Skills Library
Management & product · Automation

bootstrap-project

/bootstrap-project

Use when the friend wants to start a brand-new project's memory — nothing to scan yet, just a name. Triggers on the /ren:bootstrap-project slash command. Stamps the shared wiki skeleton (additive) and queues an empty L2 pointer-map for the project. For an EXISTING repo with real code/git history, use /ren:ingest-project instead.

Repository
ren-os ↗
Licence
MIT
Last repository change
05.09.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 05.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: lib/__init__.py

What it does and when to use it

Use when the friend wants to start a brand-new project's memory — nothing to scan yet, just a name. Triggers on the /ren:bootstrap-project slash command. Stamps the shared wiki skeleton (additive) and queues an empty L2 pointer-map for the project. For an EXISTING repo with real code/git history, use /ren:ingest-project instead.

Original author description

Use when the friend wants to start a brand-new project's memory — nothing to scan yet, just a name. Triggers on the /ren:bootstrap-project slash command. Stamps the shared wiki skeleton (additive) and queues an empty L2 pointer-map for the project. For an EXISTING repo with real code/git history, use /ren:ingest-project instead.

How it works

  1. When to use this skill
  2. When NOT to use this skill
  3. Behavior
  4. Why this reuses ingest-project's assemblel2
  5. What this skill does NOT do
  6. Failure-degradation modes
  7. References
Original SKILL.md headings · 53 lines, 857 words
SKILL.md preview
---
name: bootstrap-project
description: |
  Use when the friend wants to start a brand-new project's memory — nothing
  to scan yet, just a name. Triggers on the /ren:bootstrap-project slash
  command. Stamps the shared wiki skeleton (additive) and queues an empty L2
  pointer-map for the project. For an EXISTING repo with real code/git
  history, use /ren:ingest-project instead.
version: 0.8.8
license: MIT

framework_version: "0.8.8"
schema_version: 1
type: skill
execution_tier: deterministic

contract:
  required_outputs:
    - "Any missing shared wiki dirs/files stamped (additive, never overwrite)"
    - "If projects/<slug>/map.md doesn't exist yet: one Proposal queued (ADD, an empty L2 map). If it already exists: no proposal is queued and the existing map is left untouched."
    - "When bootstrapping inside a project repo: <repo_root>/AGENTS.md written (portability pointer surface)"
    - "Confirmation line printed to user including the queue id (or a 'map already exists' notice on the skip path)"
  budgets:
    turns: 2
    files_written: 0
    duration_seconds: 15
  permissions:
    read:
      - "~/.renos/wiki/**"
      - "wiki-skeleton/**"
    write: []
    execute: []
  completion_conditions:
    - "Either a QueueEntry exists at state_dir()/queue/<qid>.json with status=applied, op=ADD, page=projects/<slug>/map.md — or the map already existed and bootstrap() returned None with no new queue entry"
  output_paths: []

tags: [onboarding, project, l2-map, bootstrap, queue]
related_skills: [ingest-project, install, interview]
references_required: []
references_on_demand: []
---

# bootstrap-project

The fresh-project half of the L2 pair. `/ren:ingest-project` scans an existing repo for facts; this skill is for a project with nothing to scan yet — just a name and an empty map to grow into.

## When to use this skill

- Friend invokes `/ren:bootstrap-project <slug>` for a new project with no existing code/history
- Friend says: "start tracking a new project called X", "set up memory for my new idea"

## When NOT to use this skill

- The project already has real code/git history to mine → `/ren:ingest-project [path]` instead (it produces a POPULATED map, not an empty one)
- The friend wants to look something up, not create a project → `/ren:recall`

## Behavior

1. Resolve `project_slug` (kebab-case) and the active `session` id. If bootstrapping inside a project repo (the common case), resolve `repo_root=Path.cwd()`.
2. Call `importlib.import_module("skills.bootstrap-project.lib").bootstrap(project_slug, session, repo_root=repo_root)`:
   - Stamps the shared skeleton (`lib/skeleton.py` against `wiki-skeleton/manifest.yaml`'s `master` profile) into the wiki root — additive only; an already-onboarded wiki is untouched.
   - Only when `projects/<slug>/map.md` does NOT exist yet: assembles an empty L2 map (`importlib.import_module("skills.ingest-project.lib").assemble_l2` — same frozen schema `ingest` uses, just with empty `knowledge`/`pointers` and a single "project bootstrapped" log line) and proposes it (`ADD`) at `lib.memory.queue`. If the map already exists, this step is skipped entirely — no proposal, no write — and `bootstrap()` returns `None`. The map is only ever SEEDED once; its real content is grown over time by other writers (`/ren:ingest-project`, `/ren:wrap`, `/ren:pin`), and bootstrap must never re-run over that growth.
   - Stamps the manifest's `project` profile under `projects/<slug>/`: `overview.md` (the guaranteed wake-up orientation page) and, as of 0.6.2, the project-wiki skeleton — the empty `knowledge/` tree (the sanctioned home for this project's durable distilled pages, `type: project-knowledge`, `schema_version: 1`, `project: <slug>`; arbitrary-depth subdirectories, each with a hub named after the folder — `<topic>/<topic>.md`), a `schema.md` template stub (`type: project-schema` — the project's own SCHEMA document: taxonomy tree, naming conventions, what `raw/` holds; the ingest worker drafts the real taxonomy, bootstrap only marks the slot), and the empty `raw/` directory for immutable source material. Bootstrap only *creates* the skeleton; `/ren:ingest-project` and later sessions fill it, and the L2 map's Decision-map pointers index it (hubs and top-level pages, not deep leaves). Project-specific pages must NOT go in root-level `decisions/`·`patterns/`·`research/` — that's the promotion-gated instruction plane (`docs/decisions/2026-08-01-project-knowledge-subtree.md`, amended by `2026-08-01-hierarchical-project-wiki.md`).
   - Always `producer="promotion"`, `writer="human"` — a human directly asked for this, so it's never quarantined on apply.
   - When `repo_root` is given, also writes `<repo_root>/AGENTS.md` via `lib.portability.agents_surface.write_agents_md` — the thin, harness-neutral pointer file foreign coding agents (e.g. Codex) read to find this project's wiki map (Codex D5: the surface existed but had zero production callers before this wiring). A failure writing AGENTS.md never breaks bootstrap itself; omit `repo_root` (default `None`) to skip it entirely.
   - Also writes `<repo_root>/CLAUDE.md` via `lib.adapter.claude_md.write_project_claude_md(repo_root, project_slug)` — stamps the thin RenOS pointer block (managed `ren:` markers) pointing at the project's L2 map, preserving any surrounding user content. Wired as of 0.4.3 (closes a 0.2 finalize claim that had zero production callers). Same failure isolation as `AGENTS.md`: a failure never breaks bootstrap itself.
3. `ingest-project`'s `lib.ingest()` also stamps `CLAUDE.md` now (issue #15) when given `repo_root=` — same additive marker-block contract. Both skills additionally record the repo-path↔slug pair in `state_dir()/projects.json` via `ren_paths.record_project_repo` (issue #19), so `detect_project` finds the project even when the checkout dir is named differently from the slug.
4. Confirm to the user: `Queued <qid> — bootstrapped projects/<slug>/map.md`. On the skip path (map already existed, `bootstrap()` returned `None`), instead confirm: `projects/<slug>/map.md already exists — left untouched.`

## Why this reuses `ingest-project`'s `assemble_l2`

Both skills produce the SAME frozen L2 schema (`type: l2-map`, Knowledge / Decision map / Log sections) — bootstrap just starts it empty. Rendering logic lives once in `skills/ingest-project/lib`, reached here via `importlib.import_module("skills.ingest-project.lib")` (the hyphenated directory name isn't a valid Python identifier segment, so a plain dotted `import` statement can't reach it — `importlib.import_module` resolves the string path without that restriction).

## What this skill does NOT do

- Scan anything. There's no repo to scan yet — that's `/ren:ingest-project`'s job.
- Write to the wiki directly. Both the skeleton stamp (additive-only, idempotent) and the map proposal go through their respective owning mechanisms (`lib/skeleton.py`, `lib.memory.queue`) — this skill orchestrates, it doesn't write.
- Populate the Knowledge or Decision map sections. They start empty; `/ren:ingest-project`, `/ren:pin`, or `/ren:wrap` fill them in over time.

## Failure-degradation modes

| Failure | Behavior | User-visible |
|---|---|---|
| No slug given | Refuse, prompt for a name | "What should this project be called? Usage: /ren:bootstrap-project <slug>" |
| A map already exists for this slug | Map write skipped entirely — no proposal queued, existing content (however much it's grown) is untouched | "projects/<slug>/map.md already exists — left untouched." |
| Skeleton stamp finds existing user files | Skipped, reported, nothing overwritten | (silent per-file; only new entries are queued) |

## References

- Task 4.4 (`skills/ingest-project/lib/__init__.py`) — `assemble_l2`, the shared L2 renderer
- Task 0.3 (`lib/skeleton.py`, `wiki-skeleton/manifest.yaml`) — the additive skeleton stamp
- Task 2.1 (`lib/memory/queue.py`) — the single write-queue this skill's only write path
- Spec §3.1 L2 — the pointer-map definition
Files in this package (2)
  • SKILL.md 8 KB
  • lib/__init__.py 7 KB

Versions

RepositoryScoreLicence
This page · hazarsozer/ren-os90MIT
jrjsmrtn/project-orchestration-skills95MIT
seancabalse/agentic-playbook90MIT
thettwe/nyann87MIT

Database snapshot: 13.11.2026 · package version d9cd7cbe08a6 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100ingest-project
    Use when the friend wants to bring an EXISTING project (real code/git history) into their wiki as an L2 pointer-map. Triggers on the /ren:ingest-project slash command (optional [path]). A read-only scanner mines the repo for facts; the live session drafts compact knowledge +…
  • 90install
    Use for first-time setup of RenOS, or to resume a partial setup. Triggers on the /ren:install slash command. Idempotent guided flow: environment check, wiki bootstrap, optional interview, backup nag, companion offers, first project, then a closing summary of what's now possible.…
  • 96repo-bootstrap
    Use when the user asks to bootstrap a new repo or project.
  • 100project-bootstrap
    Initialize a new project context before any task exists: project folder, charter file, references skeleton, and active/ and archive/ folders for tasks. Use when starting a brand-new project, product, initiative, or client engagement with no project folder yet, or when…
  • 100bootstrap
    Bootstrap an LLM-maintained wiki for the current project. Use when a user asks to create, initialize, or refresh a project wiki, LLM wiki, QMD wiki, or codebase knowledge base for Claude Code, Codex, or Pi.
  • 100project-bootstrap
    This skill launches an interactive 8-phase new project setup wizard. Use when the user asks "create a new project", "start a project", "bootstrap project", "set up a new repo", "initialize project", "新しいプロジェクト作成", "プロジェクトを始める", or "プロジェクト立ち上げ".

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.