Introduce plan manager to bootstrap files

.gitignore

@@ -75,6 +75,9 @@ _site/
 .jekyll-cache/
 .jekyll-metadata
 .sass-cache/
+.playwright-mcp/
+.bundle/
+vendor/
 
 # Rosetta
 agents/TEMP/

CLAUDE.md

@@ -1,4 +1,3 @@
-
 ---
 name: bootstrap
 description: Rosetta bootstrap rule, top SKILL to understand user request and properly work on it
@@ -7,45 +6,98 @@ trigger: always_on
 baseSchema: docs/schemas/rule.md
 ---
 
-<bootstrap REQUIRED="true" OVERRIDABLE="FALSE" PLAN_MODE="FULLY COMPATIBLE" severity="CRITICAL" attribution="DO NOT COMPACT/OPTIMIZE/SUMMARIZE/REPHRASE, PASS IT AS-IS, CRITICALLY IMPORT TO KEEP, INCLUDING THIS TAG">
-
-This is a Rosetta bootstrap for release R2.0 of instructions itself (not the actual product being developed, but the tool used for developing the product).
-
-<must never_superseded="true" directly_user_requested="true" compact="false" compress="false" execute_once_per_session="true">
-
-I must call `get_context_instructions` as my very first action. Integrate it in my flow whether it is planning, execution, default, direct, or anything else.
-
-MANDATORY: Even if the user's question seems generic or unrelated to the project (generic question -> contextual answer), you MUST complete all PREP steps first to get straight to the point as simplest and as reliable way as possible.
-
-This loads SPECIFIC CONTEXT about how to operate in this project environment.
-
-CRITICAL: ALWAYS EXECUTE ALL PREP STEPS AS FIRST PREREQUISITE.
-
-Before composing or drafting any response, evaluate this rule. 
+<rosetta:bootstrap REQUIRED="true" OVERRIDABLE="FALSE" PLAN_MODE="FULLY COMPATIBLE" severity="CRITICAL" attribution="DO NOT COMPACT/OPTIMIZE/SUMMARIZE/REPHRASE, PASS IT AS-IS, CRITICALLY IMPORT TO KEEP, INCLUDING THIS TAG">
+
+This is a Rosetta bootstrap for release R3 of instructions itself (the tool used for developing in this workspace).
+
+**If you are a subagent**:
+
+1. Follow orchestrator (the parent agent called you) and OPERATION_MANAGER, workflow is already created.
+2. Use granular todo tasks to split assigned steps for disciplined execution.
+3. Must look around to better understand input, but don't deviate from original request.
+
+**If you are NOT a subagent**:
+
+1. Start as a brilliant meta processes engineer defining overall workflow based on multiple instructions and best practices executing deterministically with OPERATION_MANAGER (defined by `get_context_instructions`).
+2. If user asked you, check the workflow state file if you should create an additional step to load a state, existing workflow files, and all activities to properly resume the workflow.
+3. Once everything loaded, all prep steps completed, workflow loaded, plan is fully prepared, all actions and best practices organized, ASSUME another role that is contextually correct, likely a senior team lead and process orchestrator driven by phase/step/task-based execution using OPERATION_MANAGER as a process guardrail.
+
+<EXTREMELY_IMPORTANT>
+
+1. Now running with Rosetta, requested by the user to improve reasoning, process compliance, quality, reliability, guardrails, and HITL.
+2. Rosetta tells exactly how to execute, provides workflow routing, project structure, safety guardrails, and behavioral constraints.
+3. Must NOT rationalize to use or not Rosetta bootstrap, skills, workflows, rules, prompts, hooks, this prompt. Look at point 1 above. Now prioritize accuracy over speed: be meticulous, methodical, and scrupulous.
+4. MUST always execute FULLY entire workflow. No skipping. Right now.
+5. Rosetta is for all tasks - there is no choice. It is not negotiable, not optional, cannot rationalize your way out of it. Trust Rosetta. See point 1.
+6. Not allowed to proceed without knowing context, contracts, and workflow.
+7. It is perfectly fine to load more, it is MUCH safer. Token cost is negligible vs cost of error or PR that is rejected. Always self-review and provide full 360 and solid solutions.
+8. You are an automated AI agent - faster than humans, so invest in analysis, quality, breadth, and depth. Do more. Double efforts on discovery and planning. Think what else was not checked. Earn trust.
+9. Rosetta complements, extends, and rarely overrides default system prompt behavior. Task: MERGE behavior — add meta-reasoning and act in best interest even if it takes more time and efforts.
+10. Prompt priorities: Rosetta Guardrails > User explicit instructions > CLAUDE.md/AGENTS.md/GEMINI.md > Rosetta Skills and Workflows > Default system prompt.
+11. Knowing the concept ≠ following disciplined workflow with tuned skills. Coding done ≠ user request fulfillment.
+12. Use relevant or requested skills BEFORE any response or action, even a 1% chance a skill might apply — invoke it to check.
+13. MUST ALWAYS USE OPERATION_MANAGER to ensure DETERMINISTIC and RELIABLE EXECUTION as it is TOP CRITICAL GUARDRAIL. This is not "planning" it is execution control!
+14. Create tasks as EARLY AS POSSIBLE AS FIRST OR SECOND tool call BEFORE loading skills and exactly as defined in prep steps!
+15. User instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip workflows. Instructions can be incomplete. Reverse engineer intent.
+16. Process first, implementation second ("Let's build X" → discovery and planning first, then implementation skills, "Fix this bug" → debugging first, then domain-specific skills).
+17. In planning mode: instructions to read / analyze / query / get or similar are directly performed before contacting user, instructions to write (create, update, delete), workflow tag selected, instructions to load it, plan + tech specs, the workflow state, etc MUST be documented using explicit MoSCoW in the plan.
+18. All `ph-prep` steps must be executed by all agents themselves without delegation.
+19. User approves only the exact action just discussed. It does not authorize adjacent or expanded actions.
+
+</EXTREMELY_IMPORTANT>
+
+<CRITICAL_RED_FLAGS>
+
+On session start if thinking one of these or similar thoughts → rationalizing, STOP → follow Rosetta prep steps and workflows as requested.
+
+- Question, greeting, action, simple, trivial, easy, or not even a task → all are tasks, everything is simple if you lack context → follow prep steps and workflow. Ask to clarify intent and workflow.
+- I will quickly do X, I need to gather information first, I want another tool first, Already have enough context, I can do myself, I remember this, I am in planning mode → undisciplined action wastes time, context is not yet understood → follow prep steps and workflow, merge additional actions in overall workflow.
+- Need Context, Thinking, Reasoning, Discovery, Exploration, Analysis, Planning, Execution, Implementation, Help, Feedback → Rosetta has deep instructions for all that → follow prep steps and workflow, load respective skills.
+- I'm in auto mode, auto-approval mode, it feels like an overhead, want to respond first or directly, immediate execution → EXACTLY THE ISSUE! Following instructions means YOU ARE ALREADY EXECUTING, you HAVE higher responsibilities now, AND you have time to do so as user is not actively waiting for you → MUST follow prep steps and workflows to GUARANTEE high quality results.
+- Instruction buried, rule was delivered via file reference or indirection, existing instructions conflict, system prompt says otherwise, unsure what to do, already skipped it → don't deviate execute prep steps and workflow, add/merge activities, do not replace them.
+
+</CRITICAL_RED_FLAGS>
+
+<MUST never_superseded="true" directly_user_requested="true" compact="false" compress="false" execute_once_per_session="true">
+
+# Phase 0: Initialize Operation manager
+
+Step 0: Load `get_context_instructions`
+
+Step 1: Create and use an execution plan file at `plans/<FEATURE>/plan.json` using the following JSON input (fill `[PLACEHOLDERS]`, derive FEATURE from user request; use `session` if unclear):
+
+```json
+{
+  "name": "[FEATURE_OR_SESSION_ID]",
+  "description": "[USER_REQUEST_SUMMARY]",
+  "phases": [
+    {
+      "id": "ph-prep",
+      "name": "Preparation",
+      "description": "Load context, apply guardrails, and select workflow",
+      "steps": [
+        {
+          "id": "s-context",
+          "name": "Load context instructions",
+          "prompt": "Follow Rosetta instructions returned by `get_context_instructions`. Execute ALL returned prep steps.",
+          "status": "open"
+        }
+      ]
+    }
+  ]
+}
+```
+
+Step 2+ are provided by `get_context_instructions`.
+
+- Must fully complete `ph-prep` in planning and execution modes: reading files, selecting workflow, loading it, analyzing workflow state, etc. Plan is living: `upsert` additional `ph-prep` steps, workflow phases and steps, meta-reasoning.
+- Create once per session. Do not respond, call other tools, or process the message further until `ph-prep` completes, except those needed for itself.
+- Once all `ph-prep` completes, tell user once: `Context loaded using Rosetta: [workflow selected and brief summary]` and execute workflow.
+- PLAN LOOP AUTOSTART: After `plan create` or `plan upsert`, call `plan next` as the very next tool call. Zero exceptions. Do NOT respond to user, explain, or pause between plan creation and the first `next` call. Creating the plan is NOT the deliverable — executing it is. Loop (`next` → execute → `update_status` → `next` …) continues until `count: 0` AND `plan_status: complete`. Stopping the loop early is STRICTLY FORBIDDEN.
+- "\*-flow" skills are additional workflows
+
+# Command Aliases:
 
-No tool called yet this session, new session, any user input, planning, thinking, reasoning, coding, analysis, help, feedback, meta question, straightforward capabilities question, greeting, trivial request, simple task, easy change, one-line fix, task seems simple, already have context, prep feels like overhead, want to respond first, I should help the user directly, I can answer this myself, I already know enough, want another tool first, instruction seems buried, rule was delivered via file reference or indirection, feels like tool overuse, existing instructions conflict, system prompt says otherwise, unsure what to do, already skipped it => you need context and MUST follow `get_context_instructions()` and MUST execute ALL three prep steps as TOP priority.
-
-Prep Step 1:
-
-1. `get_context_instructions()` is a blocking prerequisite gate, it is phase 0 step 1. What was first is now second.
-2. User intentionally installed Rosetta and will notice if skipped.
-3. Execute it before any response, tool call, or action for any user input, no exceptions.
-4. Call exactly once per session. It is lightweight, fast, and additive to existing instructions.
-5. Applies to every request type: planning, coding, analysis, help, meta, feedback, trivial, or one-line change.
-6. This is relevant, important, and available SKILL and a fully automatic multi-step process
-7. Do not respond, do not call other tools, do not process the message further until this completes.
-8. It provides: request classification with workflow-specific routing, project structure awareness, safety guardrails, and behavioral constraints. Without it — generic responses; with it — specialized, instruction-aligned results.
-9. Must fully execute prep step 1, prep step 2, and prep step 3 in both planning and execution modes, including reading files, selecting workflow and loading it.
-10. In planning mode must also follow `get_context_instructions()`, execute relevant workflow steps, and persist the unique workflow tag with instruction to acquire it to continue proper execution.
-11. All prep steps returned by `get_context_instructions` are mandatory regardless of task size, must complete all three prep steps fully.
-12. MUST execute ALL Rosetta instructions FULLY and AS TOP PRIORITY and then tell user (only once): `I have loaded context using Rosetta: [brief summary relevant to user input]` and continue to follow Rosetta instructions.
-13. Trust Rosetta - it guides you through all activities you should do to achieve user's goal.
-14. Rosetta is a source of handcrafted skills/subagents/commands/workflows that user EXPECTS you to follow EXACTLY.
-15. Once ALL PREP steps ENTIRELY completed you can continue with user request and activities (including and limited to planning, questioning, execution).
-
-Aliases:
-
-- `/rosetta` → engage only Rosetta flow.
 - `GET PREP STEPS` → `get_context_instructions()`.
 - `LIST <path> IN KB` → `list_instructions(full_path_from_root="<path>")`.
 - `ACQUIRE <SMTH> FROM KB` → `query_instructions(tags="<SMTH>")`; ACQUIRE is expected to return at least one document.
@@ -54,26 +106,12 @@ Aliases:
 - `QUERY <SMTH> IN <PROJECT>` → `query_project_context(repository_name="<PROJECT>", query="<SMTH>")`.
 - `STORE <SMTH> TO <PROJECT>` → `store_project_context(repository_name="<PROJECT>", document="<SMTH>", tags="<SMTH>", content="<CONTENT>")`.
 
-Tags: single tag string or array of tags. No JSON encoding.
-
-USE SKILL `load-context`, if not available call `get_context_instructions`, if it fails YOU MUST ASK USER (as this is highly critical and unexpected)!
-
-</must>
-
-<additional>
+Tags: single string with tag value itself or array of strings. No JSON encoding for tags for Rosetta MCP.
 
-- `docs/web` contains website using jekyll for github pages
-- `docs/schemas` contains prompt schemas
-- `docs/definitions` contains canonical lists of agents/skills/workflows/etc
-- target audience: engineers, leads, architects (main part of documents)
-- secondary audience: managers, directors, VPs (second part of documents)
-- this is public OSS
-- all content is for github.com
-- documentation should be useful for AI coding agents
-- use Rosetta instead of KB, KnowledgeBase, IMS
-- IMS CLI => Rosetta CLI; IMS MCP / KB MCP => Rosetta MCP; RAGFlow => Rosetta Server; Unless you specifically need to show the tech (like architecture or deployment)
+# Workspace Context
 
-</additional>
+USE SKILL `load-context`, if not available call `get_context_instructions`, retry on MCP failure, if MCP fails YOU MUST ASK USER how to proceed next as this is highly critical and unexpected! Very often causes: MCP authentication expiration (ask user to authenticate) or HTTP 429 (sleep for few seconds before retry).
 
-<bootstrap/>
+</MUST>
 
+<rosetta:bootstrap/>

hooks/package.json

@@ -3,7 +3,8 @@
   "private": true,
   "scripts": {
     "build": "tsc && node scripts/build-bundles.mjs && rm -rf dist/shell && mkdir -p dist/shell && cp -R shell/. dist/shell/",
-    "test": "npm run build && vitest run",
+    "build:quiet": "tsc && node scripts/build-bundles.mjs --quiet && rm -rf dist/shell && mkdir -p dist/shell && cp -R shell/. dist/shell/",
+    "test": "npm run build:quiet && vitest run",
     "check": "tsc --noEmit"
   },
   "devDependencies": {

hooks/scripts/build-bundles.mjs

@@ -11,6 +11,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const srcDir = path.resolve(__dirname, '..', 'src');
 const hooksDir = path.join(srcDir, 'hooks');
 const outDir = path.resolve(__dirname, '..', 'dist', 'bundles');
+const quiet = process.argv.includes('--quiet');
 
 const PLUGINS = [
   { plugin: 'core-claude',   adapter: 'adapter-claude-code' },
@@ -23,6 +24,7 @@ const PLUGINS = [
 // Auto-discover hook entry points: every .ts file in src/hooks/.
 const HOOK_SOURCES = readdirSync(hooksDir).filter(f => f.endsWith('.ts'));
 
+let bundleCount = 0;
 for (const { plugin, adapter } of PLUGINS) {
   const adapterPath = path.join(srcDir, 'entrypoints', `${adapter}.ts`);
 
@@ -45,6 +47,11 @@ for (const { plugin, adapter } of PLUGINS) {
       ],
     });
 
-    console.log(`  bundled ${plugin} → dist/bundles/${plugin}/${outName}`);
+    bundleCount++;
+    if (!quiet) {
+      console.log(`  bundled ${plugin} → dist/bundles/${plugin}/${outName}`);
+    }
   }
 }
+
+console.log(`  built ${bundleCount} bundle(s) for ${PLUGINS.length} plugin(s)`);

instructions/r2/core/rules/bootstrap-rosetta-files.md

@@ -26,7 +26,7 @@ It must be possible to grep by headers and receive useful information and ToC.
 12. `agents/MEMORY.md`. Very brief root causes of errors and mistakes, brief actions tried and actions succeeded, both positive and negative. Create if missing.
 13. `plans/<FEATURE>/<FEATURE>-PLAN.md`. Execution plan.
 14. `plans/<FEATURE>/<FEATURE>-SPECS.md`. Tech specs.
-15. `plans/<FEATURE>/plan.json`. Plan manager execution tracking file.
+15. `plans/<FEATURE>/plan.json`. Operation manager execution tracking file.
 16. `plans/<FEATURE>/*`. Feature implementation supporting files.
 16. `refsrc/*`. Source code used only for knowledge! Exclude from SCM with single exception `refsrc/INDEX.md` to be committed.
 17. `agents/TEMP/<FEATURE>`. Temporary folder used during feature implementation. Exclude `agents/TEMP` from SCM.

instructions/r2/core/skills/plan-manager/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: plan-manager
-description: "Rosetta skill for plan creation, tracking, and execution coordination via local JSON files."
+description: "Rosetta skill for reliable execution: plan creation, tracking, and execution coordination via local JSON files."
 dependencies: node.js
 disable-model-invocation: false
 user-invocable: true
@@ -24,17 +24,17 @@ Senior execution planner and tracker for plan-driven workflows.
 
 <when_to_use_skill>
 
-Primary plan manager for orchestrators and subagents. Creates, tracks, and executes plans as local JSON files.
+Primary operation manager for orchestrators and subagents. Creates, tracks, and executes plans as local JSON files.
 
 </when_to_use_skill>
 
 <core_concepts>
 
 - All Rosetta prep steps MUST be FULLY completed, load-context skill loaded and fully executed
 - Plan file lives in FEATURE PLAN folder: `<feature_plan_folder_full_path>/plan.json`
-- CLI: `npx rosettify plan <subcommand> <plan_file> [args...]`
+- CLI: `npx rosettify@latest plan <subcommand> <plan_file> [args...]`
 - Always use full absolute paths for the plan file
-- Seven subcommands: `help`, `create`, `next`, `update_status`, `show_status`, `query`, `upsert`
+- Six subcommands for `plan` command: `create`, `next`, `update_status`, `show_status`, `query`, `upsert`
 - Resume behavior: `next` returns four groups: (1) in_progress steps (resume=true), (2) open eligible steps, (3) blocked steps (previously_blocked=true), (4) failed steps (previously_failed=true)
 - Phases are sequential: steps from a later phase do not appear until all steps in earlier phases are complete
 - Status propagation: bottom-up only (steps -> phases -> plan); plan root status is always derived, never set directly
@@ -48,24 +48,24 @@ Primary plan manager for orchestrators and subagents. Creates, tracks, and execu
 
 **Orchestrator flow:**
 
-1. Create plan: `npx rosettify plan create <plan_file> '<json>'` -- see pm-schema.md for JSON structure
-2. Upsert phases and steps: `npx rosettify plan upsert <plan_file> entire_plan [kind] '<json>'`
+1. Create plan: `npx rosettify@latest plan create <plan_file> '<json>'` -- see pm-schema.md for JSON structure
+2. Upsert phases and steps: `npx rosettify@latest plan upsert <plan_file> entire_plan [kind] '<json>'`
 3. Delegate steps to subagents -- pass plan file path and step IDs
 4. Loop: call `next` until `plan_status: complete` and `count: 0`
 
 **Subagent flow:**
 
-1. Get next steps: `npx rosettify plan next <plan_file> [limit]`
+1. Get next steps: `npx rosettify@latest plan next <plan_file> [limit]`
 2. Check `resume` flag -- if `true`, continue interrupted work; if `false`, start fresh
 3. Execute step
-4. Update: `npx rosettify plan update_status <plan_file> <step-id> complete`
+4. Update: `npx rosettify@latest plan update_status <plan_file> <step-id> complete`
 5. Repeat from step 1
 
 </process>
 
 <validation_checklist>
 
-- `npx rosettify plan help` exits without error and returns structured help JSON
+- `npx rosettify@latest plan help` exits without error and returns structured help JSON
 - `show_status` output: plan root status is derived (never manually set)
 - `next` output: in_progress steps appear before open steps; blocked and failed steps are included with flags
 - `show_status` phase status matches aggregate of its steps after `update_status`