prizmkit 1.1.154 → 1.1.156

package/bundled/dev-pipeline/tests/test_unified_cli.py

@@ -479,7 +479,7 @@ def test_operation_first_runtime_arguments_are_validated_then_forwarded_exactly(
 
     run_args = [
         "run", "feature", "F-001", "custom.json", "--features", "F-001:F-005",
-        "--max-retries", "5", "--max-infra-retries", "4", "--mode", "full",
+        "--max-retries", "5", "--max-infra-retries", "4",
         "--resume-phase", "6", "--dry-run",
     ]
     assert runtime_cli.main(run_args) == 0
@@ -488,8 +488,8 @@ def test_operation_first_runtime_arguments_are_validated_then_forwarded_exactly(
     assert runtime_cli.main(["status", "bugfix", "bugs.json"]) == 0
     assert captured[-1] == ("status", "status", "bugfix", ("bugs.json",))
 
-    assert runtime_cli.main(["daemon", "feature", "start", "--mode", "standard"]) == 0
-    assert captured[-1] == ("daemon", "start", "feature", ("--mode", "standard"))
+    assert runtime_cli.main(["daemon", "feature", "start"]) == 0
+    assert captured[-1] == ("daemon", "start", "feature", ())
 
     assert runtime_cli.main(["daemon", "feature", "logs", "--follow"]) == 0
     assert captured[-1] == ("daemon", "logs", "feature", ("--follow",))
@@ -503,21 +503,31 @@ def test_operation_first_runtime_arguments_are_validated_then_forwarded_exactly(
         "reset", "reset", "feature", ("F-001", "--fresh-checkout", "custom.json")
     )
 
-    interspersed_daemon = ["daemon", "feature", "start", "--mode", "full", "custom.json"]
+    interspersed_daemon = ["daemon", "feature", "start", "custom.json"]
     assert runtime_cli.main(interspersed_daemon) == 0
     assert captured[-1] == (
-        "daemon", "start", "feature", ("--mode", "full", "custom.json")
+        "daemon", "start", "feature", ("custom.json",)
     )
 
     assert runtime_cli.main(["--project-root", "feature", "run", "feature", "--dry-run"]) == 0
     assert captured[-1] == ("run", "run", "feature", ("--dry-run",))
 
 
+def test_pipeline_mode_option_is_rejected():
+    foreground = run_cli("run", "feature", "--mode", "full")
+    daemon = run_cli("daemon", "feature", "start", "--mode", "full")
+
+    assert foreground.returncode == 2
+    assert daemon.returncode == 2
+    assert "unrecognized arguments" in foreground.stderr
+    assert "unrecognized arguments" in daemon.stderr
+
+
 @pytest.mark.parametrize(
     ("family", "task_id", "extra_args"),
     [
         ("feature", "F-007", ("--features", "F-007", "--dry-run")),
-        ("bugfix", "B-007", ("--mode", "full", "--max-retries", "4")),
+        ("bugfix", "B-007", ("--max-retries", "4")),
         ("refactor", "R-007", ("--resume-phase", "6", "--max-infra-retries", "5")),
     ],
 )
@@ -625,6 +635,32 @@ def _write_family_status_plan(paths, family, task_id):
     return plan_path
 
 
+def _write_family_runtime_status(paths, family, task_id):
+    state_dir = {
+        "feature": paths.feature_state_dir,
+        "bugfix": paths.bugfix_state_dir,
+        "refactor": paths.refactor_state_dir,
+    }[family]
+    status_path = state_dir / task_id / "status.json"
+    status_path.parent.mkdir(parents=True, exist_ok=True)
+    status_path.write_text(
+        json.dumps(
+            {
+                {
+                    "feature": "feature_id",
+                    "bugfix": "bug_id",
+                    "refactor": "refactor_id",
+                }[family]: task_id,
+                "retry_count": 0,
+                "sessions": [],
+                "resume_from_phase": 9,
+            }
+        ),
+        encoding="utf-8",
+    )
+    return status_path
+
+
 def _file_bytes_under(root):
     if not root.exists():
         return {}
@@ -676,29 +712,26 @@ def test_status_all_uses_real_family_status_handlers_without_filesystem_mutation
     from prizmkit_runtime.paths import resolve_runtime_paths
 
     paths = resolve_runtime_paths(pipeline_root=PIPELINE_ROOT, project_root=tmp_path)
-    feature_plan = _write_family_status_plan(paths, "feature", "F-001")
-    refactor_plan = _write_family_status_plan(paths, "refactor", "R-001")
-    before = {
-        path.relative_to(tmp_path).as_posix(): (path.read_bytes(), path.stat().st_mtime_ns)
-        for path in (feature_plan, refactor_plan)
+    configured = {
+        "feature": "F-001",
+        "bugfix": "B-001",
+        "refactor": "R-001",
     }
+    for family, task_id in configured.items():
+        _write_family_status_plan(paths, family, task_id)
+        _write_family_runtime_status(paths, family, task_id)
+    before = _file_bytes_under(tmp_path)
 
     result = run_cli("--project-root", str(tmp_path), "status", "all")
 
-    after = {
-        path.relative_to(tmp_path).as_posix(): (path.read_bytes(), path.stat().st_mtime_ns)
-        for path in (feature_plan, refactor_plan)
-    }
     assert result.returncode == 0, result.stderr
     assert "FEATURE\n=======" in result.stdout
     assert "Python feature status" in result.stdout
-    assert "BUGFIX\n======\nnot configured: plan list not found" in result.stdout
+    assert "BUGFIX\n======" in result.stdout
+    assert "Python bugfix status" in result.stdout
     assert "REFACTOR\n========" in result.stdout
     assert "Python refactor status" in result.stdout
-    assert after == before
-    assert not paths.feature_state_dir.exists()
-    assert not paths.bugfix_state_dir.exists()
-    assert not paths.refactor_state_dir.exists()
+    assert _file_bytes_under(tmp_path) == before
 
 
 def test_status_all_reports_plan_and_handler_errors_but_renders_unaffected_sections(
@@ -1254,7 +1287,7 @@ def test_session_preamble_writes_redacted_start_command_for_all_launch_profiles(
             assert str(prompt) not in "\n".join(lines[:6])
 
 
-def test_headless_review_guidance_defers_to_skill_review_contract():
+def test_headless_review_guidance_maps_stage_local_skill_result():
     headless_guidance_files = [
         REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-review-full.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
@@ -1270,9 +1303,10 @@ def test_headless_review_guidance_defers_to_skill_review_contract():
 
     for path in headless_guidance_files:
         text = path.read_text(encoding="utf-8")
-        assert "current review contract" in text, path
-        assert "second review path outside that contract" in text, path
+        assert "returns only `PASS` or `NEEDS_FIXES`" in text, path
+        assert "this injected session" in text, path
         assert "text final-verdict" in text, path
+        assert "follow the skill's current review contract" not in text, path
         assert "low=0" not in text and "Reviewer 3" not in text, path
         assert "forced-worktree changed-content fallback" not in text, path
         assert "isolation:" not in text, path
@@ -3060,6 +3094,60 @@ def test_branch_merge_preserves_preexisting_stash_when_workspace_is_clean(tmp_pa
     assert (tmp_path / "feature.txt").read_text(encoding="utf-8") == "done\n"
 
 
+def test_branch_merge_fast_forwards_with_dirty_prizmkit_internal_state(tmp_path):
+    from prizmkit_runtime.gitops import (
+        BranchContext,
+        branch_fast_forward_possible,
+        branch_merge_plan,
+        run_git_plan,
+    )
+
+    _init_merge_repo(tmp_path)
+    context = BranchContext("main", "dev/example", tmp_path)
+    subprocess.run(
+        ["git", "checkout", "-b", context.working_branch],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "feature"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"session-local"}\n', encoding="utf-8")
+
+    assert branch_fast_forward_possible(tmp_path, context) is True
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(context, rebase=False),
+    )
+
+    assert result.ok is True
+    assert not any(command.args and command.args[0] == "rebase" for command in result.plan.commands)
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "main"
+    assert (tmp_path / "feature.txt").read_text(encoding="utf-8") == "done\n"
+    assert json.loads(manifest.read_text(encoding="utf-8"))["version"] == "session-local"
+    assert ".prizmkit/manifest.json" in subprocess.run(
+        ["git", "status", "--short"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+    assert _stash_oids(tmp_path) == ()
+
+
 def test_branch_merge_rejects_dirty_task_checkout_without_touching_stashes(tmp_path):
     from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
 
@@ -3794,6 +3882,60 @@ def test_materialize_worktree_support_assets_copies_ignored_assets_without_retir
     assert guarded_worktree_remove(runtime, delete_branch=False).ok
 
 
+def test_linked_worktree_fast_forwards_with_dirty_prizmkit_internal_state(tmp_path):
+    from prizmkit_runtime.gitops import (
+        BranchContext,
+        WorktreePolicy,
+        branch_fast_forward_possible,
+        ensure_linked_worktree,
+        guarded_worktree_remove,
+        merge_linked_worktree,
+        worktree_runtime_context,
+    )
+
+    repo = tmp_path / "repo"
+    _init_temp_repo(repo)
+    config = repo / ".prizmkit" / "config.json"
+    config.parent.mkdir(parents=True)
+    config.write_text('{"mode":"base"}\n', encoding="utf-8")
+    subprocess.run(["git", "add", ".prizmkit/config.json"], cwd=repo, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "track internal config"],
+        cwd=repo,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
+    runtime = worktree_runtime_context(
+        BranchContext("main", "dev/internal-dirt", repo),
+        WorktreePolicy(
+            True,
+            cleanup_on_success=True,
+            preserve_on_failure=True,
+            worktree_root=tmp_path / "worktrees",
+        ),
+    )
+    assert ensure_linked_worktree(runtime).ok
+    (runtime.worktree_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=runtime.worktree_path, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "feature"],
+        cwd=runtime.worktree_path,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
+    worktree_config = runtime.worktree_path / ".prizmkit" / "config.json"
+    worktree_config.write_text('{"mode":"session-local"}\n', encoding="utf-8")
+
+    assert branch_fast_forward_possible(repo, runtime.context) is True
+    result = merge_linked_worktree(runtime)
+
+    assert result.ok is True
+    assert not any(item.args and item.args[0] == "rebase" for item in result.results)
+    assert (repo / "feature.txt").read_text(encoding="utf-8") == "done\n"
+    assert json.loads(worktree_config.read_text(encoding="utf-8"))["mode"] == "session-local"
+    assert guarded_worktree_remove(runtime, delete_branch=True).ok
+
+
 def test_worktree_terminal_failure_wip_commit_preserves_dirty_changes_before_cleanup(tmp_path):
     from prizmkit_runtime.gitops import (
         BranchContext,
@@ -3875,9 +4017,9 @@ def test_checkpoint_rewind_preserves_planning_and_resets_implementation_downstre
         "prizmkit-implement",
         "prizmkit-code-review",
         "prizmkit-test",
+        "completion-summary",
         "prizmkit-retrospective",
         "prizmkit-committer",
-        "completion-summary",
     ]
     steps = []
     previous = None
@@ -3909,7 +4051,7 @@ def test_checkpoint_rewind_preserves_planning_and_resets_implementation_downstre
         "feature_state": {
             "schema_version": 1,
             "artifact_dir": ".prizmkit/specs/example",
-            "orchestrator": "prizmkit-l4",
+            "orchestrator": "pipeline-runtime",
             "stage": "code-review",
             "current_stage": "prizmkit-code-review",
             "status": "failed",

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.154",
+  "version": "1.1.156",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",
@@ -23,35 +23,35 @@
       "hasScripts": false
     },
     "prizmkit-plan": {
-      "description": "Formal requirement lifecycle entry: natural language → spec.md and plan.md with mandatory Main-Agent planning review, optional capability-gated independent correctness review, stable artifact identity, and workflow-state handoff.",
+      "description": "Create and review spec.md and plan.md for one supplied requirement; return PLAN_READY or PLAN_BLOCKED.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": true,
       "hasScripts": false
     },
     "prizmkit-implement": {
-      "description": "Execute a reviewed formal requirement plan, preserve artifact identity, and route implementation repairs to the correct review or test gate.",
+      "description": "Execute one reviewed plan or explicit repair scope, perform focused verification, and return IMPLEMENTED or IMPLEMENT_BLOCKED.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
       "hasScripts": false
     },
     "prizmkit-code-review": {
-      "description": "Mandatory bounded Main-Agent code review plus optional capability-gated independent correctness review, with evidence-based adjudication, direct repairs, verification, and append-only progress reporting.",
+      "description": "Review one supplied change with bounded Main-Agent repair, optional capability-gated independent review, verification, and PASS or NEEDS_FIXES output.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
       "hasScripts": true
     },
     "prizmkit-committer": {
-      "description": "Final formal-requirement commit gate: verifies all prior stages, confirms interactive commits or performs authorized headless pipeline commits, and never pushes automatically.",
+      "description": "Create an explicitly confirmed interactive commit or prepare an exact Runtime commit request from caller-supplied evidence; never push automatically.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
       "hasScripts": false
     },
     "prizmkit-retrospective": {
-      "description": "Mandatory formal-requirement retrospective: updates durable Prizm docs or records NO_DOC_CHANGE with machine-verifiable result before commit.",
+      "description": "Synchronize durable Prizm docs for exact supplied change paths, or record NO_DOC_CHANGE; return RETRO_COMPLETE or RETRO_BLOCKED.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": true,
@@ -72,7 +72,7 @@
       "hasScripts": false
     },
     "prizmkit-test": {
-      "description": "AI-led project-native testing for the affected business module and Regression Ring, with bounded failure repair, mandatory Main-Agent review, optional strict independent Test Reviewer, and TEST_PASS/TEST_NEEDS_FIXES/TEST_BLOCKED results.",
+      "description": "AI-led project-native affected-module and Regression Ring testing with contract authority, test-double fidelity, consumer/provider compatibility, browser and Full-stack E2E classification, persistence re-entry, bounded repair, review, and TEST_PASS/TEST_NEEDS_FIXES/TEST_BLOCKED results.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
@@ -159,12 +159,12 @@
       "hasScripts": false
     },
     "recovery-workflow": {
-      "description": "Detect whether interrupted work belongs to a direct requirement or autonomous pipeline, select the authoritative owner, and hand off without merging state machines.",
+      "description": "Detect valid active feature, bugfix, or refactor checkout records and return exact operation-first continuation commands without executing or mutating state.",
       "tier": "companion",
       "category": "orchestration-skill",
       "subcategory": "workflows",
       "hasAssets": false,
-      "hasScripts": false
+      "hasScripts": true
     }
   },
   "suites": {

package/bundled/skills/app-planner/SKILL.md

@@ -157,7 +157,7 @@ After Infrastructure configuration is complete (CP-AP-1.5), check whether the pr
 
 Rules are optional. If the user skips, AI uses general best practices freely — no reminders, no blocking.
 
-→ Read `${SKILL_DIR}/references/rules-configuration.md` for the full procedure: layer detection, configuration mode selection, interactive Q&A per layer, template rendering, and root.prizm RULES pointer update. Before rendering final rule files or updating the pointer, run the Pre-Generation Headless Context Completeness Gate on every proposed new or changed rule.
+→ Read `${SKILL_DIR}/references/rules-configuration.md` for the full contract: layer detection, explicit Quick/Full/Skip authorization, interactive decisions, invariant-only fixed rules, selected-option derivation with semantic fallback, dual-native profiles, conflict detection, deterministic resource validation, template rendering, and the `root.prizm` `RULES:` pointer update. Run `${SKILL_DIR}/scripts/validate-rules-configuration.py` before questioning and again before final rendering. Before writing rule files or updating the pointer, require both a passing decision-conflict gate and the Pre-Generation Headless Context Completeness Gate for every proposed new or changed rule.
 
 ### After rules configuration
 
@@ -289,7 +289,7 @@ Checkpoints catch cascading errors early — skipping one means the next phase b
 | **CP-AP-0** | Intent Confirmed | User confirmed session goal (produce / explore) | 1 |
 | **CP-AP-1** | Conventions Checked | Current-host project instruction target resolved; its `### Project Conventions` section is loaded or asked and up to date | 1 |
 | **CP-AP-1.5** | Infrastructure Checked | Resolved project instruction target `### Infrastructure` section addressed — database, deployment **and cloud services** each configured or explicitly deferred | 1-2 |
-| **CP-AP-1.6** | Rules Configured | For each detected layer (from config.json or self-detection), rules file exists in `.prizmkit/rules/` or user explicitly skipped. `root.prizm` `RULES:` pointer up-to-date. | 2 |
+| **CP-AP-1.6** | Rules Configured | Rules resources pass deterministic validation; Quick defaults are explicitly authorized; every detected layer has a conflict-free `.prizmkit/rules/<layer>-rules.md` or an explicit skip; dual-native choices use separate profiles; no residual placeholders remain; `root.prizm` `RULES:` pointer is up to date. | 2 |
 | **CP-AP-2** | Vision Summary | Goal/users/differentiators confirmed by user. For brownfield: existing purpose confirmed or refined. | 1-2 |
 | **CP-AP-3** | Frontend Design Evaluated | For frontend projects: checked for existing UI/UX design system; user was asked if missing. **Auto-pass** for backend-only or non-UI projects. | 2 |
 | **CP-AP-4** | Project Brief Accumulated | The in-memory brief or `.prizmkit/plans/project-brief.draft.md` contains at least 3 ideas. For brownfield: already-implemented items marked `[x]` count toward this total. The final brief is not written before CP-AP-5.5. | 3 |
@@ -304,7 +304,7 @@ Run this gate before any final handoff whenever the current `app-planner` sessio
 1. **Load the local reference**: read `${SKILL_DIR}/references/generated-plan-review.md` and follow it as the source of truth for app-planner generated content review.
 2. **Read actual planning artifacts directly**: inspect current-session final outputs such as `.prizmkit/plans/project-brief.md`, changed sections in the resolved project instruction target, `.prizmkit/rules/<layer>-rules.md`, and `.prizmkit/prizm-docs/root.prizm` `RULES:` pointer line. Do not rely on `git status`, `git diff`, or `git diff --cached`, because `.prizmkit` planning artifacts are often gitignored or untracked.
 3. **Scope to new/changed app-planning content**: compare against pre-session snapshots or in-memory drafts when available. Preserve unchanged historical brief items, instruction-file sections, rules files, and Prizm doc content. For explore-only sessions, draft-save exits, or flows with no new final planning content, report: `Local generated-plan review: not applicable — no new final planning content written.`
-4. **Run the local checklist and fresh-session simulation** from the reference: project brief completeness, consistency of conventions/infrastructure/architecture decisions, rules pointer consistency, normalization of selected decisions, purpose-tagged references, app-planner writable-boundary compliance, and downstream `feature-planner` readiness to produce `.prizmkit/plans/feature-list.json` without guessing or seeing the original conversation.
+4. **Run the local checklist and fresh-session simulation** from the reference: project brief completeness; consistency of conventions, infrastructure, and architecture decisions; Rules Configuration resource-validation and conflict-gate evidence; selected-decision precedence; explicit not-applicable/deferred sections; dual-native profile separation; rules pointer consistency; normalization of selected decisions; purpose-tagged references; app-planner writable-boundary compliance; and downstream `feature-planner` readiness to produce `.prizmkit/plans/feature-list.json` without guessing or seeing the original conversation.
 5. **Apply accepted fixes through the source/writer path**: project brief fixes go through the draft/checklist source, instruction-file section fixes go through the resolved project instruction target's section source with user confirmation when changing approved wording, rules fixes re-render from rules configuration answers/templates when available, and `root.prizm` fixes are limited to the `RULES:` pointer line.
 6. **Recheck changed sections directly** after every accepted fix batch.
 7. **Report CP-AP-6** in the completion summary: include local generated-plan review verdict, reviewed app-planning artifacts/sections, accepted fixes (or "none"), and final writer/validation result.

package/bundled/skills/app-planner/references/generated-plan-review.md

@@ -33,7 +33,7 @@ Do not rely on `git status`, `git diff`, or `git diff --cached` to decide whethe
 
 - `project-brief.md` fixes go through the draft/checklist project brief source representation described in `project-brief-guide.md`, then rewrite the final brief through the existing project brief writer path.
 - Project conventions, infrastructure, frontend design direction, and architecture decisions are source sections in the exact project instruction target selected for the current session. If a fix changes user-approved wording or meaning, ask for user confirmation before rewriting.
-- `.prizmkit/rules/<layer>-rules.md` fixes should re-render from the rules configuration answers and template inputs when available. If no structured source remains, update the source rule section explicitly and report that source path.
+- `.prizmkit/rules/<layer>-rules.md` fixes should re-render from the normalized decision ledger, invariant/derivation sources, and template inputs. Rerun `scripts/validate-rules-configuration.py` and the Rules Configuration conflict gate before rewriting. If no structured source remains, rebuild the decision ledger or ask for clarification; do not hand-patch a contradictory final rule file.
 - `root.prizm` fixes are limited to correcting or adding the `RULES:` pointer line; do not rewrite unrelated root content.
 
 ## Review Checklist
@@ -43,6 +43,7 @@ For every reviewed app-planning artifact or section, check:
 - Project brief completeness: goal, users, differentiators, constraints, tech stack assumptions, and at least three actionable ideas when producing a final brief
 - Consistency among conventions, infrastructure, architecture decisions, and project brief content
 - Infrastructure completeness or explicit deferral for database, deployment, and cloud services topics when those flows ran
+- Rules Configuration integrity: the deterministic resource validator passed; Quick defaults were explicitly authorized; fixed content contains only invariants; selected decisions own their policy domains; no active rule conflicts with the decision ledger; unmatched/not-applicable choices are explicit; dual-native decisions remain in separate iOS/Android profiles; and rendered files contain no residual placeholders
 - Rules pointer consistency: generated `.prizmkit/rules/<layer>-rules.md` files are referenced by the `root.prizm` `RULES:` line when rules were configured
 - Substantive user meaning and detail preservation at matching detail after conversational normalization in project brief ideas, conventions, infrastructure notes, architecture decisions, and rules
 - Artifact-wide readability: every generated natural-language value across all AI-visible fields and sections—including briefs/drafts, instruction sections, generated rules, appendices, comments, brainstorm summaries, quoted evidence, and parentheticals—is a standalone domain statement without dialogue-role labels, question IDs, answer tokens, planning-option recommendation markers, raw answer-map content, or planning provenance