@juancr11/sibu 0.9.5 → 0.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juancr11/sibu",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "CLI for setting up a local AI-augmented development workflow.",
   "repository": {
     "type": "git",

package/templates/AGENTS.md

@@ -14,6 +14,7 @@
 ## Agent-specific instructions
 
 - Before any task that writes or modifies code, propose a brief plan and wait for user confirmation once per requested task.
+- Exception: when the user asks to plan, implement, execute, continue, or work through a User Story or Epic with `ai-implementation-plan-executor`, that request is confirmation to generate any missing implementation plan and begin execution immediately. Do not require a separate plan approval gate; wait only for the story-level review after implementation finishes.
 - For read-only work, research, planning, documentation-only edits, or other non-code changes, do not ask for confirmation unless the action is destructive, risky, ambiguous, or explicitly requires user approval.
 - After confirmation, proceed with all agreed in-scope changes without re-asking.
 - Ask again only if the scope changes materially, the approach becomes materially more complex or risky, or the user explicitly asks to review before continuing.
@@ -36,7 +37,7 @@ Keep responses concise by default, but spend the context needed for correctness,
 
 ## Skill routing
 
-For planned product/feature work, use this pipeline: product vision -> deep module map -> feature brief -> technical design -> optional UX -> epics/stories -> AI implementation plan -> AI executor. Narrow code fixes and small local changes do not require the full pipeline unless product scope, module ownership, or architecture direction is unclear.
+For planned product/feature work, use this pipeline: product vision -> deep module map -> feature brief -> technical design -> optional UX -> epics/stories -> AI executor. The executor creates a missing AI implementation plan and then executes it immediately when a story or Epic is requested for planning, implementation, or continuation. Narrow code fixes and small local changes do not require the full pipeline unless product scope, module ownership, or architecture direction is unclear.
 
 - For any code-writing task, use `clean-code`.
 - For requests to create, revise, or clarify a product vision, product strategy narrative, product north star, positioning, product principles, product voice, target user definition, product boundaries, or success signals, use `product-vision-writer`.
@@ -44,8 +45,8 @@ For planned product/feature work, use this pipeline: product vision -> deep modu
 - For requests to create, revise, or clarify a business-level feature brief after Deep Module Map work, feature definition, feature scope, MVP feature boundaries, business acceptance criteria, or product-level feature rationale, use `feature-brief-writer`.
 - For requests to create, revise, or clarify a technical design, implementation-oriented design doc, architecture approach, technical tradeoffs, technical risks, or implementation plan for an approved feature, use `technical-design-writer`.
 - For requests to create Epics, User Stories, Scrum planning artifacts, backlog slices, or delivery plans from an approved feature brief and technical design, use `scrum-master-planner`.
-- For requests to turn a specific User Story into an implementation checklist, coding plan, step-by-step execution plan, or baby-step plan, use `ai-implementation-planner`.
-- For requests to implement, execute, continue, or work through a specific User Story under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.md` or an existing story implementation plan under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.impl_plan/`, use `ai-implementation-plan-executor`; when the story plan is missing, the executor should create it with `ai-implementation-planner` and immediately continue into implementation without a separate plan approval gate.
+- For explicit planning-only requests to turn a specific User Story into an implementation checklist, coding plan, step-by-step execution plan, or baby-step plan without implementation, use `ai-implementation-planner` and stop after writing the plan. Treat a request as planning-only only when the user explicitly says planning-only, "do not implement," or asks to create the plan without execution.
+- For requests to plan, implement, execute, continue, or work through a specific User Story under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.md`, an Epic, or an existing story implementation plan under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.impl_plan/`, use `ai-implementation-plan-executor`; when the story plan is missing, the executor must create it with `ai-implementation-planner` and immediately continue into implementation without a separate plan approval gate.
 {{OPTIONAL_SKILL_ROUTING}}
 
 ## Sibu maintenance

package/templates/manifest.json

@@ -1,11 +1,11 @@
 {
-  "templateVersion": "82",
+  "templateVersion": "86",
   "templates": {
     "AGENTS.md": {
-      "version": "26",
+      "version": "28",
       "description": "Project-level agent instructions and Sibu maintenance guidance.",
       "changes": [
-        "Updates implementation routing so missing story plans are generated and executed immediately without a separate plan approval gate."
+        "Routes story and Epic planning requests to the executor by default so generated plans are implemented immediately unless planning-only is explicit."
       ]
     },
     ".codex/config.toml": {
@@ -136,17 +136,17 @@
       ]
     },
     "skills/ai-implementation-planner/SKILL.md": {
-      "version": "12",
+      "version": "15",
       "description": "Mandatory AI implementation planner skill for turning one approved User Story into small, story-local implementation step files.",
       "changes": [
-        "Removes the implementation-plan approval gate and allows execution to continue immediately when implementation is requested."
+        "Clarifies that the planner is normally an executor helper and stops after planning only when planning-only is explicit."
       ]
     },
     "skills/ai-implementation-plan-executor/SKILL.md": {
-      "version": "18",
+      "version": "22",
       "description": "Mandatory AI implementation plan executor skill for implementing full story plans before story-level review and commit.",
       "changes": [
-        "Allows the executor to generate missing story plans and immediately implement them, preserving only the story-level review gate after implementation."
+        "Clarifies that story and Epic planning requests are confirmation for executor implementation."
       ]
     },
     "skills/ai-prompt-engineer-master/SKILL.md": {

package/templates/skills/ai-implementation-plan-executor/SKILL.md

@@ -25,6 +25,7 @@ Execute one existing story implementation plan completely, one ordered step file
 - Step approval metadata in every completed step file only after explicit story-level user approval.
 - One focused commit for the approved story implementation, excluding any paths ignored by Git.
 - When starting or continuing a story that has no plan, story-local implementation step files created by applying `ai-implementation-planner`, followed immediately by implementation.
+- When an Epic is complete, the next Epic in the same feature is selected by inspecting the feature's `epics/` folder, then the first story in that Epic is planned and implemented immediately.
 
 ### When this skill stops
 
@@ -104,7 +105,8 @@ If the initial User Story has no matching `.impl_plan/`, or the initial `.impl_p
 1. Apply `ai-implementation-planner` to create or repair the story-local implementation plan.
 2. Quality-check that the generated plan has ordered step files for exactly that story.
 3. Immediately begin executing the generated plan with this executor.
-4. Do not ask the user to approve the plan before implementation; the only required approval is the story-level review after implementation finishes.
+4. Treat the planner as an internal helper, not a user-visible stopping point.
+5. Do not ask the user to approve the plan before implementation; the only required approval is the story-level review after implementation finishes.
 
 If required source context is missing:
 
@@ -117,7 +119,7 @@ If required source context is missing:
 
 Work through the full story plan in filename order, one step at a time, without asking for review or approval between steps.
 
-When a valid implementation plan exists, begin implementing the first unapproved step immediately. If a plan was just generated by `ai-implementation-planner`, begin implementing it immediately. Do not ask for pre-implementation confirmation or plan approval before changing code. This is an explicit exception to repository-level instructions that normally require confirmation before code changes: selecting this executor skill, asking to implement or continue a story/Epic, or providing a valid plan is the user's confirmation to implement the full story plan.
+When a valid implementation plan exists, begin implementing the first unapproved step immediately. If a plan was just generated by `ai-implementation-planner`, begin implementing it immediately. Do not ask for pre-implementation confirmation or plan approval before changing code. This is an explicit exception to repository-level instructions that normally require confirmation before code changes: selecting this executor skill, asking to plan, implement, execute, or continue a story/Epic, or providing a valid plan is the user's confirmation to implement the full story plan.
 
 A step file is considered approved only when it contains this section:
 
@@ -137,7 +139,7 @@ When starting or resuming a plan:
 6. Stop only for ambiguity, missing required files, conflicting scope, failed validation that cannot be safely fixed within the plan, or material risk.
 7. After the final unapproved step is implemented, report what changed, validation results, and any risks, then wait for explicit story-level approval.
 
-Do not mark steps approved, commit changes, or move to the next story until the user explicitly approves the completed story implementation.
+Do not mark steps approved, commit changes, move to the next story, or move to the next Epic until the user explicitly approves the completed story implementation.
 
 ## Story review gate
 
@@ -161,17 +163,19 @@ After writing approval markers, commit only the non-ignored changes produced by
 
 Use a Conventional Commits 1.0.0 message that describes the completed story. If the commit fails, stop and report the failure instead of continuing.
 
-## Epic continuation check
+## Feature continuation check
 
-After the approved story implementation is committed:
+After the approved story implementation is committed, continue through the current feature unless there is no next story or Epic to implement.
 
 1. Inspect the current Epic's `stories/` folder in filename order.
 2. Identify whether there is a next User Story after the completed story.
-3. If there is no next User Story in the Epic, tell the user the Epic appears ready and stop.
-4. If a next User Story exists and its `.impl_plan/` folder exists with ordered step files, immediately begin implementing that next story plan using this same story execution model.
-5. If a next User Story exists but its `.impl_plan/` folder is missing or empty, immediately create the implementation plan for that story by applying `ai-implementation-planner`, then immediately begin implementing the generated plan.
+3. If a next User Story exists and its `.impl_plan/` folder exists with ordered step files, immediately begin implementing that next story plan using this same story execution model.
+4. If a next User Story exists but its `.impl_plan/` folder is missing or empty, immediately create the implementation plan for that story by applying `ai-implementation-planner`, then immediately begin implementing the generated plan.
+5. If there is no next User Story in the current Epic, inspect the current feature's `epics/` folder and choose the next logical Epic to implement. Do not choose by filename alone. Base the choice on dependencies, prerequisite capabilities, technical sequencing, risk reduction, feature value, story readiness, and whether the Epic can be implemented without violating the feature brief or technical design. Briefly report the selected Epic and why it is the logical next step.
+6. If a next logical Epic exists, inspect its `stories/` folder, select the first logical unapproved User Story to implement, create its implementation plan if needed with `ai-implementation-planner`, and immediately begin implementing it. Prefer story order when it reflects dependencies; otherwise choose based on prerequisites, risk, and value sequence.
+7. If no logical next Epic exists or every Epic in the feature has all stories approved, tell the user the feature appears ready and stop.
 
-This continuation behavior is an explicit exception to the normal hard-start rule only after a story has been approved and committed. It lets the executor keep an Epic moving while preserving only the story-level review gate after implementation.
+This continuation behavior is an explicit exception to the normal hard-start rule only after a story has been approved and committed. It lets the executor keep a feature moving across stories and Epics while preserving only the story-level review gate after each story implementation.
 
 ## Implementation rules
 
@@ -190,13 +194,13 @@ Do:
 
 Do not:
 
-- create a missing initial plan from scratch
+- invent a missing plan manually instead of applying `ai-implementation-planner`
 - mark any step approved before the user explicitly approves the completed story
 - commit story implementation changes before story approval
 - add product scope absent from the story, Epic, feature brief, technical design, or step files
 - silently move work into unrelated or unapproved Deep Modules
 - continue past a failed validation without reporting it and asking how to proceed
-- leave committable approved story changes uncommitted before moving to the next story
+- leave committable approved story changes uncommitted before moving to the next story or Epic
 - attempt to stage or commit story files, approval markers, or other paths that are ignored by Git
 
 ## Final response behavior
@@ -208,11 +212,12 @@ After implementing all unapproved steps in one story, briefly report:
 - the steps completed
 - validations run and their results
 - notable risks or follow-up questions, if any
-- that you are waiting for story approval before marking all completed steps approved, committing eligible non-ignored changes, and continuing the Epic
+- that you are waiting for story approval before marking all completed steps approved, committing eligible non-ignored changes, and continuing the feature
 
-After approving and committing a story implementation, briefly report the commit and the Epic continuation result:
+After approving and committing a story implementation, briefly report the commit and the feature continuation result:
 
 - commit hash when a commit was created, or a note that only ignored changes existed and no commit was created
-- next story is being implemented immediately because it already has a plan
-- next story was planned and implementation started immediately
-- or the Epic appears ready
+- next story in the current Epic is being implemented immediately because it already has a plan
+- next story in the current Epic was planned and implementation started immediately
+- next Epic selected and its first unapproved story is being planned/implemented immediately
+- or the feature appears ready

package/templates/skills/ai-implementation-planner/SKILL.md

@@ -7,7 +7,7 @@ description: Turn one approved User Story Markdown file into LLM-sized implement
 
 ## Purpose
 
-Turn one approved User Story into concrete Markdown step files an AI coding agent can execute safely and completely. This skill owns implementation planning for one story at a time, not product scope, technical design decisions, Scrum planning, or code implementation. After writing the plan, it does not require a separate plan approval gate; implementation may continue immediately through `ai-implementation-plan-executor` when the user requested execution or Epic continuation.
+Turn one approved User Story into concrete Markdown step files an AI coding agent can execute safely and completely. This skill owns implementation planning for one story at a time, not product scope, technical design decisions, Scrum planning, or code implementation. This planner is normally an internal helper for `ai-implementation-plan-executor`; after writing a valid plan, implementation must continue immediately through the executor unless the user explicitly requested planning-only.
 
 ## Pipeline Contract
 
@@ -29,7 +29,7 @@ Turn one approved User Story into concrete Markdown step files an AI coding agen
 - The user does not provide or clearly identify exactly one User Story file.
 - Any required source artifact is missing, incomplete, or invalid in a way its owning stage should repair.
 - The story or feature has UI impact and `ux.md` is missing; direct the user to `ux-expert`.
-- The request is to write production code, execute an implementation plan, create stories, or perform another pipeline stage.
+- This planner was invoked directly for a request that should route to another pipeline stage, such as writing production code, executing an existing implementation plan, creating stories, or performing another pipeline stage.
 
 ### What this skill must not do
 
@@ -37,7 +37,7 @@ Turn one approved User Story into concrete Markdown step files an AI coding agen
 - Do not modify prior-stage artifacts.
 - Do not reread `docs/deep-module-map.md` by default; trust `technical_design.md` for Deep Module implementation boundaries.
 - Do not infer implementation scope from an Epic brief, feature brief, or technical design without exactly one User Story.
-- Do not write production code directly from this planner; hand off to `ai-implementation-plan-executor` for implementation.
+- Do not write production code directly from this planner; hand off to `ai-implementation-plan-executor` for implementation. The executor is the orchestrator for planning, implementation, execution, continuation, and combined plan-and-execute requests.
 
 ## Required input
 
@@ -242,11 +242,11 @@ Before finishing, verify:
 
 ### 6. Continue or report
 
-After writing and quality-checking the implementation step files, do not ask for plan approval before execution. If the user asked to implement, execute, continue, or work through the story or Epic, immediately hand off to `ai-implementation-plan-executor` for the newly created plan in the same turn. The user's execution request plus a valid generated plan is enough pre-implementation confirmation; the only required user approval is the story-level review after execution finishes.
+After writing and quality-checking the implementation step files, do not ask for plan approval before execution. Unless the user explicitly requested planning-only, immediately hand off to `ai-implementation-plan-executor` for the newly created plan in the same turn. The user's story or Epic planning/execution request plus a valid generated plan is enough pre-implementation confirmation; the only required user approval is the story-level review after execution finishes.
 
-If the user asked only to create a plan and did not ask for implementation, stop after creating the plan and report where it was written. Make clear that no plan approval is required before a later executor run.
+If the user explicitly asked for planning-only, said not to implement, or asked to create the plan without execution, stop after creating the plan and report where it was written. Make clear that no plan approval is required before a later executor run.
 
-When this skill is invoked as the next-story planning handoff from `ai-implementation-plan-executor`, create the plan and immediately return control to the executor so it can implement the next story without a plan-review gate.
+When this skill is invoked as the next-story or next-Epic planning handoff from `ai-implementation-plan-executor`, create the plan and immediately return control to the executor so it can implement that story without a plan-review gate.
 
 The final planning-only response must briefly include: