prizmkit 1.1.148 → 1.1.150

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

@@ -2412,8 +2412,16 @@ def test_git_branch_worktree_plans_preserve_shell_invariants(tmp_path):
     assert any(command.args[:2] == ("rebase", "--abort") for command in ensure.commands)
     assert any(command.args[:2] == ("add", "-A") for command in ensure.commands)
     assert not any(command.args and command.args[0] == "stash" for command in ensure.commands)
+    assert not any(command.args and command.args[0] in {"merge", "push"} for command in save_wip.commands + ensure.commands)
+    assert not any(command.args[:2] == ("branch", "-d") for command in save_wip.commands + ensure.commands)
     assert ensure.never_fails is False
-    assert any(".*/worktrees/**" in " ".join(command.args) for command in save_wip.commands)
+    assert any(command.args == ("add", "-A", "--", ".") for command in save_wip.commands)
+    assert not any(
+        "exclude" in arg
+        for command in save_wip.commands
+        if command.args[:2] == ("add", "-A")
+        for arg in command.args
+    )
     assert worktree.commands[0].args[:2] == ("worktree", "add")
 
     allowed_failure_result = GitPlanResult(
@@ -2587,16 +2595,27 @@ def test_branch_return_ignores_installed_runtime_paths_without_blocking_wip_comm
     from prizmkit_runtime.gitops import branch_ensure_return
 
     _init_merge_repo(tmp_path)
-    (tmp_path / ".gitignore").write_text(".prizmkit/*\n.claude/\n", encoding="utf-8")
+    (tmp_path / ".gitignore").write_text(
+        ".prizmkit/*\n.claude/\n.codebuddy/\n.agents/\n.pi\n",
+        encoding="utf-8",
+    )
     subprocess.run(["git", "add", ".gitignore"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "ignore installed runtime"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
-    runtime_file = tmp_path / ".prizmkit" / "dev-pipeline" / "cli.py"
-    runtime_file.parent.mkdir(parents=True)
-    runtime_file.write_text("# installed runtime\n", encoding="utf-8")
+    ignored_files = (
+        tmp_path / ".prizmkit" / "dev-pipeline" / "cli.py",
+        tmp_path / ".claude" / "runtime.json",
+        tmp_path / ".codebuddy" / "runtime.json",
+        tmp_path / ".agents" / "runtime.json",
+        tmp_path / ".pi" / "runtime.json",
+    )
+    for ignored_file in ignored_files:
+        ignored_file.parent.mkdir(parents=True, exist_ok=True)
+        ignored_file.write_text("ignored support\n", encoding="utf-8")
     manifest = tmp_path / ".prizmkit" / "manifest.json"
     manifest.write_text('{}\n', encoding="utf-8")
     subprocess.run(["git", "checkout", "-b", "dev/interrupted"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
     (tmp_path / "interrupted.txt").write_text("preserved\n", encoding="utf-8")
+    (tmp_path / "interrupted [literal]*.txt").write_text("special path\n", encoding="utf-8")
 
     result = branch_ensure_return(tmp_path, "main", "dev/interrupted")
 
@@ -2607,6 +2626,168 @@ def test_branch_return_ignores_installed_runtime_paths_without_blocking_wip_comm
     assert subprocess.run(
         ["git", "show", "dev/interrupted:interrupted.txt"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
     ).stdout == "preserved\n"
+    assert subprocess.run(
+        ["git", "show", "dev/interrupted:interrupted [literal]*.txt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == "special path\n"
+    committed_paths = subprocess.run(
+        ["git", "ls-tree", "-r", "--name-only", "dev/interrupted"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.splitlines()
+    assert not any(path.startswith((".claude/", ".codebuddy/", ".agents/", ".pi/")) for path in committed_paths)
+
+
+def test_clean_branch_return_skips_wip_commit_and_checks_out_base(tmp_path):
+    from prizmkit_runtime.gitops import branch_ensure_return
+
+    _init_merge_repo(tmp_path)
+    base_head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+    subprocess.run(["git", "checkout", "-b", "dev/clean-interrupt"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    result = branch_ensure_return(tmp_path, "main", "dev/clean-interrupt")
+
+    assert result.ok is True
+    assert not any(command_result.args[:1] == ("commit",) for command_result in result.results)
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "main"
+    assert subprocess.run(
+        ["git", "rev-parse", "dev/clean-interrupt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == base_head
+
+
+def test_branch_return_commits_staged_unstaged_deleted_renamed_and_special_paths(tmp_path):
+    from prizmkit_runtime.gitops import branch_ensure_return
+
+    _init_merge_repo(tmp_path)
+    tracked_paths = {
+        "mixed.txt": "base mixed\n",
+        "delete me.txt": "delete me\n",
+        "rename source.txt": "rename me\n",
+    }
+    for relative, content in tracked_paths.items():
+        (tmp_path / relative).write_text(content, encoding="utf-8")
+    subprocess.run(["git", "add", "--", *tracked_paths], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "wip matrix base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "-b", "dev/wip-matrix"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    (tmp_path / "mixed.txt").write_text("staged version\n", encoding="utf-8")
+    subprocess.run(["git", "add", "mixed.txt"], cwd=tmp_path, check=True)
+    (tmp_path / "mixed.txt").write_text("final unstaged version\n", encoding="utf-8")
+    (tmp_path / "delete me.txt").unlink()
+    subprocess.run(["git", "mv", "rename source.txt", "renamed [literal]*.txt"], cwd=tmp_path, check=True)
+    (tmp_path / "new [literal]*.txt").write_text("new special\n", encoding="utf-8")
+
+    result = branch_ensure_return(tmp_path, "main", "dev/wip-matrix")
+
+    assert result.ok is True
+    assert subprocess.run(
+        ["git", "branch", "--show-current"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip() == "main"
+    assert subprocess.run(
+        ["git", "show", "dev/wip-matrix:mixed.txt"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout == "final unstaged version\n"
+    assert subprocess.run(
+        ["git", "show", "dev/wip-matrix:renamed [literal]*.txt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == "rename me\n"
+    assert subprocess.run(
+        ["git", "show", "dev/wip-matrix:new [literal]*.txt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == "new special\n"
+    task_tree = subprocess.run(
+        ["git", "ls-tree", "-r", "--name-only", "dev/wip-matrix"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.splitlines()
+    assert "delete me.txt" not in task_tree
+    assert "rename source.txt" not in task_tree
+
+
+def test_branch_return_rejects_unmerged_paths_without_commit_or_checkout(tmp_path):
+    from prizmkit_runtime.gitops import branch_ensure_return
+
+    _init_merge_repo(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/conflicted"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("task side\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "task side"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("base side\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "base side"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "dev/conflicted"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    merge = subprocess.run(
+        ["git", "merge", "main"],
+        cwd=tmp_path,
+        check=False,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    assert merge.returncode != 0
+    head_before = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip()
+
+    result = branch_ensure_return(tmp_path, "main", "dev/conflicted")
+
+    assert result.ok is False
+    assert "unresolved Git paths" in result.results[-1].stderr
+    assert subprocess.run(
+        ["git", "branch", "--show-current"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip() == "dev/conflicted"
+    assert subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip() == head_before
+    assert subprocess.run(
+        ["git", "ls-files", "-u"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip()
+
+
+def test_branch_save_wip_rejects_clean_recorded_branch_mismatch(tmp_path):
+    from prizmkit_runtime.gitops import branch_save_wip
+
+    _init_merge_repo(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/unrelated"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    result = branch_save_wip(tmp_path, "dev/recorded-task")
+
+    assert result.ok is False
+    assert result.results[-1].stderr == "Active branch dev/unrelated does not match task branch dev/recorded-task"
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "dev/unrelated"
 
 
 def test_branch_return_commit_failure_does_not_checkout_base(monkeypatch, tmp_path):
@@ -3104,3 +3285,142 @@ def test_daemon_status_cli_preserves_pure_json_stdout(tmp_path):
     assert "Python feature daemon" not in result.stdout
     assert "Transition command contract" not in result.stdout
 
+
+def test_active_checkout_replacement_is_guarded_and_never_writes_reset_tombstone(tmp_path):
+    from prizmkit_runtime.task_checkout import (
+        TaskCheckout,
+        TaskCheckoutError,
+        load_task_checkout,
+        persist_task_checkout,
+        replace_active_task_checkout_locked,
+    )
+
+    state_dir = tmp_path / "state"
+    expected = TaskCheckout.active("feature", "F-001", "dev/F-001-old", "main")
+    replacement = TaskCheckout.active("feature", "F-001", "dev/F-001-resume", "main")
+    persist_task_checkout(state_dir, expected)
+
+    path = replace_active_task_checkout_locked(state_dir, expected, replacement)
+
+    assert path == state_dir / "F-001" / "checkout.json"
+    loaded = load_task_checkout(state_dir, "feature", "F-001")
+    assert loaded == replacement
+    assert loaded is not None and loaded.is_reset is False
+    with pytest.raises(TaskCheckoutError, match="changed before recovery replacement"):
+        replace_active_task_checkout_locked(state_dir, expected, replacement)
+
+
+def test_checkpoint_rewind_preserves_planning_and_resets_implementation_downstream():
+    from prizmkit_runtime.checkpoint_state import (
+        rewind_checkpoint_for_implementation,
+        validate_checkpoint_data,
+    )
+
+    skills = [
+        "prizmkit-plan",
+        "prizmkit-implement",
+        "prizmkit-code-review",
+        "prizmkit-test",
+        "prizmkit-retrospective",
+        "prizmkit-committer",
+        "completion-summary",
+    ]
+    steps = []
+    previous = None
+    for index, skill in enumerate(skills, start=1):
+        status = "pending"
+        stage_result = None
+        if skill == "prizmkit-plan":
+            status, stage_result = "completed", "PLAN_READY"
+        elif skill == "prizmkit-implement":
+            status, stage_result = "completed", "IMPLEMENTED"
+        elif skill == "prizmkit-code-review":
+            status, stage_result = "failed", "REVIEW_NEEDS_FIXES"
+        step = {
+            "id": f"S{index:02d}",
+            "skill": skill,
+            "name": skill,
+            "status": status,
+            "depends_on": previous,
+            "required_artifacts": [],
+        }
+        if stage_result:
+            step["stage_result"] = stage_result
+        steps.append(step)
+        previous = step["id"]
+    payload = {
+        "version": 1,
+        "workflow_type": "feature-pipeline",
+        "steps": steps,
+        "feature_state": {
+            "schema_version": 1,
+            "artifact_dir": ".prizmkit/specs/example",
+            "orchestrator": "prizmkit-l4",
+            "stage": "code-review",
+            "current_stage": "prizmkit-code-review",
+            "status": "failed",
+            "stage_result": "REVIEW_NEEDS_FIXES",
+            "repair_scope": "production",
+            "repair_round": 2,
+            "next_stage": "prizmkit-implement",
+            "resume_from": "prizmkit-implement",
+            "blocked_reason": "review_needs_fixes",
+            "terminal_status": "WORKFLOW_BLOCKED",
+            "completed_stages": ["plan", "implement"],
+        },
+    }
+
+    rewound = rewind_checkpoint_for_implementation(payload)
+
+    assert rewound is not payload
+    assert rewound["steps"][0] == payload["steps"][0]
+    assert all(step["status"] == "pending" for step in rewound["steps"][1:])
+    assert all("stage_result" not in step for step in rewound["steps"][1:])
+    semantic = rewound["feature_state"]
+    assert semantic["stage"] == "implement"
+    assert semantic["current_stage"] == "prizmkit-implement"
+    assert semantic["status"] == "pending"
+    assert semantic["repair_round"] == 0
+    assert semantic["completed_stages"] == ["plan"]
+    assert semantic["blocked_reason"] is None
+    assert semantic["terminal_status"] is None
+    assert "stage_result" not in semantic
+    validated = validate_checkpoint_data(rewound)
+    assert validated.valid is True
+    assert validated.current_step is not None
+    assert validated.current_step.skill == "prizmkit-implement"
+
+
+def test_git_recovery_helpers_create_branch_without_checkout_and_report_registration(tmp_path):
+    from prizmkit_runtime.gitops import (
+        create_branch_from_base,
+        local_branch_exists,
+        registered_worktrees,
+    )
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base\n", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    assert local_branch_exists(tmp_path, "main") is True
+    assert local_branch_exists(tmp_path, "missing") is False
+    result = create_branch_from_base(tmp_path, "dev/F-001-resume", "main")
+
+    assert result.return_code == 0
+    assert local_branch_exists(tmp_path, "dev/F-001-resume") is True
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "main"
+    registrations = registered_worktrees(tmp_path)
+    assert any(
+        registration.path == tmp_path.resolve() and registration.branch == "main"
+        for registration in registrations
+    )
+

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.148",
+  "version": "1.1.150",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",

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

@@ -36,18 +36,18 @@ If you believe the task is better suited for a different workflow, you MUST:
 **Your ONLY writable outputs are:**
 1. `.prizmkit/plans/project-brief.md` (`.prizmkit/plans/` — accumulated project context brief)
 2. `.prizmkit/plans/project-brief.draft.md` — working source during planning and saved draft when the user exits before completion
-3. Project conventions and architecture decisions appended to `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` (with user consent)
-4. Infrastructure configuration (database conventions, deployment config, **cloud services**) appended to `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` `### Infrastructure` section
-5. `.prizmkit/rules/<layer>-rules.md` — per-layer development rules generated by Rules Configuration
-6. `.prizmkit/prizm-docs/root.prizm` — `RULES:` pointer line only (not other root.prizm content; created minimally if absent)
-
-**Project instruction file selection**:
-- If `.prizmkit/manifest.json` exists, use its `platform` field as the source of truth.
-- Codex → `AGENTS.md`
-- Claude Code → `CLAUDE.md`
-- CodeBuddy → `CODEBUDDY.md`
-- `all` → all three files.
-- Only when the manifest is missing, fall back to installed PrizmKit-owned platform files such as `.claude/commands/prizmkit.md`, `.agents/skills/prizmkit/SKILL.md`, or `.codebuddy/skills/prizmkit/SKILL.md`. Do not treat a generic `.agents/` directory as Codex.
+3. The resolved project instruction target for the current AI host (with user consent) — only project conventions, infrastructure configuration (database conventions, deployment config, **cloud services**), frontend design direction, and architecture decisions
+4. `.prizmkit/rules/<layer>-rules.md` — per-layer development rules generated by Rules Configuration
+5. `.prizmkit/prizm-docs/root.prizm` — `RULES:` pointer line only (not other root.prizm content; created minimally if absent)
+
+**Current-host project instruction target resolution**:
+- Identify the current AI host from direct runtime/session evidence and the host's own project conventions. Installed project resources, existing project files, and `.prizmkit/manifest.json` are supporting evidence only; they are not a platform identity or path allowlist and must not override stronger current-session evidence.
+- Resolve the host's conventional main project-level AI instruction/context file: a project-local, durable file that the current host loads or reads to guide AI work in this project.
+- Named paths such as `AGENTS.md`, `CLAUDE.md`, `CODEBUDDY.md`, and `.pi/APPEND_SYSTEM.md` are non-exhaustive examples only. They do not define a platform-to-path mapping or a compliance condition.
+- The target must stay inside the project, represent the current host's main user-facing project instruction context, and must not be a private or framework-protocol-only import file.
+- If the conventional target is absent, create it only when current-host evidence establishes one unambiguous conventional project path and the user consents to the write.
+- If no target can be identified confidently or multiple plausible targets remain, use `AskUserQuestion` to confirm the intended project instruction file before writing. Never guess, and never treat semantic detection as permission to write an arbitrary file.
+- Resolve the target once before project-convention discovery and reuse the same resolved target for conventions, infrastructure, frontend design direction, architecture decisions, prerequisites, checkpoints, generated-plan review, and completion reporting. Do not mirror content to every installed host merely because multiple platform resources exist.
 
 **After planning is complete**, you MUST:
 1. Present the summary of captured project-level context (vision, conventions, architecture decisions, project brief)
@@ -130,7 +130,7 @@ Do NOT use this skill when:
    - During brainstorm Phase C → also read `${SKILL_DIR}/references/red-team-checklist.md`
 
 3. **Project conventions discovery** — after Intent Confirmation, before brainstorm or vision work:
-   → Read `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` and check for `### Project Conventions` section
+   → Resolve the current host's project instruction target through **Current-host project instruction target resolution**, then read that exact target and check for a `### Project Conventions` section
    → If section exists and covers the project well → skip silently
    → If section is missing or incomplete → run the **AI-driven convention discovery** below:
 
@@ -138,14 +138,14 @@ Do NOT use this skill when:
 
    → Read `${SKILL_DIR}/references/project-conventions-discovery.md` for the full AI-driven discovery procedure (Analyze → Reason → Present via AskUserQuestion).
 
-   → Normalize each proposed convention into a standalone domain rule, run the Pre-Generation Headless Context Completeness Gate, then save only passing convention meanings to `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` under `### Project Conventions` (one bullet per convention; no raw answers or planning provenance)
+   → Normalize each proposed convention into a standalone domain rule, run the Pre-Generation Headless Context Completeness Gate, then save only passing convention meanings to the resolved project instruction target under `### Project Conventions` (one bullet per convention; no raw answers or planning provenance)
    → Output format will naturally vary per project — that is the intended behavior
 
    **Infrastructure Convention Discovery (Database + Deployment)**
 
-   After project conventions are captured, check the project instruction file for `### Infrastructure` section status. Read `${SKILL_DIR}/references/infrastructure-convention-discovery.md` for the full database (6 topics — table naming, field naming, migrations, primary keys, indexes, environment separation), deployment (4 topics — target refinement, existing infrastructure, AI-assisted deploy, env var management), and cloud services (2-round AskUserQuestion) inquiry procedures. Follow the inquiry flow there — use `AskUserQuestion` for each batch. Each question MUST include a "Skip — decide later" option.
+   After project conventions are captured, check the resolved project instruction target for `### Infrastructure` section status. Read `${SKILL_DIR}/references/infrastructure-convention-discovery.md` for the full database (6 topics — table naming, field naming, migrations, primary keys, indexes, environment separation), deployment (4 topics — target refinement, existing infrastructure, AI-assisted deploy, env var management), and cloud services (2-round AskUserQuestion) inquiry procedures. Follow the inquiry flow there — use `AskUserQuestion` for each batch. Each question MUST include a "Skip — decide later" option.
 
-   After inquiry, run the Pre-Generation Headless Context Completeness Gate on every proposed infrastructure decision, then update the `### Infrastructure` section in the project instruction file with passing content (see reference file for full output format). Items still marked "Skip — decide later" remain as `<!-- [topic]: deferred -->` for `prizmkit-deploy` to pick up later.
+   After inquiry, run the Pre-Generation Headless Context Completeness Gate on every proposed infrastructure decision, then update the `### Infrastructure` section in the resolved project instruction target with passing content (see reference file for full output format). Items still marked "Skip — decide later" remain as `<!-- [topic]: deferred -->` for `prizmkit-deploy` to pick up later.
 
 4. **Project brief accumulation** — throughout all interactive phases:
    → Read `${SKILL_DIR}/references/project-brief-guide.md` for template and rules
@@ -168,8 +168,8 @@ Proceed to Prerequisites and continue the app-planner workflow.
 Before questions, check optional context files (never block if absent):
 - `.prizmkit/prizm-docs/root.prizm` (architecture/project context)
 - `.prizmkit/config.json` (existing stack preferences and detected tech stack)
-- `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` `### Project Conventions` section (previously answered project conventions)
-- `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` `### Infrastructure` section (database and deployment config from prizmkit-init or previous app-planner run)
+- Resolved project instruction target `### Project Conventions` section (previously answered project conventions)
+- Resolved project instruction target `### Infrastructure` section (database and deployment config from prizmkit-init or previous app-planner run)
 
 **Tech stack auto-population from config.json:**
 - If `.prizmkit/config.json` contains a `tech_stack` object, use it to pre-fill tech assumptions.
@@ -287,8 +287,8 @@ Checkpoints catch cascading errors early — skipping one means the next phase b
 | Checkpoint | Artifact/State | Criteria | Phase |
 |-----------|----------------|----------|-------|
 | **CP-AP-0** | Intent Confirmed | User confirmed session goal (produce / explore) | 1 |
-| **CP-AP-1** | Conventions Checked | Project conventions loaded or asked; `### Project Conventions` section in `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` up to date | 1 |
-| **CP-AP-1.5** | Infrastructure Checked | Infrastructure config loaded or asked; `### Infrastructure` section in `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` addressed — database, deployment **and cloud services** each configured or explicitly deferred | 1-2 |
+| **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-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 |
@@ -302,10 +302,10 @@ Checkpoints catch cascading errors early — skipping one means the next phase b
 Run this gate before any final handoff whenever the current `app-planner` session wrote or rewrote final app-level planning content. In full produce mode this runs after CP-AP-5.5 and the passing content's final writes; in Quick Context Mode it runs after the confirmed `.prizmkit/plans/project-brief.md` write; in conventions, infrastructure, architecture-decision, or rules-only final-write flows it runs after those writes and before the completion summary. This gate reviews generated planning artifacts directly, not implementation diffs.
 
 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`, selected `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` sections, `.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.
+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.
-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 selected platform instruction file 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.
+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.
 
@@ -314,8 +314,8 @@ Run this gate before any final handoff whenever the current `app-planner` sessio
 After Phase 2, if framework-shaping architecture decisions emerged during planning (tech stack, communication patterns, data model strategies — not individual feature details), read `${SKILL_DIR}/references/architecture-decisions.md` and follow the capture flow. Most sessions will NOT produce architecture decisions — only capture when genuinely impactful.
 
 **How it works**:
-1. If decisions are captured → run the Pre-Generation Headless Context Completeness Gate on each decision, then append passing decisions to `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` under `### Architecture Decisions` section
-2. Downstream skills (feature-planner, prizmkit-plan, etc.) read `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` as standard context, so they automatically receive these decisions
+1. If decisions are captured → run the Pre-Generation Headless Context Completeness Gate on each decision, then append passing decisions to the resolved project instruction target under `### Architecture Decisions`
+2. Downstream skills (feature-planner, prizmkit-plan, etc.) read the current host's project instruction context, so they automatically receive these decisions
 3. Do NOT write architecture decision content directly to `.prizmkit/prizm-docs/root.prizm` — that file is maintained by `prizmkit-prizm-docs` and `prizmkit-retrospective`. (The `RULES:` pointer line is managed by Rules Configuration, not by this section.) If the project needs `.prizmkit/prizm-docs/`, recommend the user run `prizmkit-prizm-docs` init after planning.
 
 ## Project Brief Accumulation
@@ -348,10 +348,10 @@ When the session appears to be ending:
 After CP-AP-6 passes or is reported not applicable, present a summary and end the session:
 
 1. **Summary** (as text): List all project-level artifacts produced:
-   - Project conventions → `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` `### Project Conventions`
-   - Infrastructure config → `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` `### Infrastructure` (database conventions + deployment config)
+   - Project conventions → resolved project instruction target `### Project Conventions`
+   - Infrastructure config → resolved project instruction target `### Infrastructure` (database conventions + deployment config)
    - Tech stack assumptions → captured in `.prizmkit/plans/project-brief.md` and reused from `.prizmkit/config.json` when it already exists
-   - Architecture decisions (if any) → `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` `### Architecture Decisions`
+   - Architecture decisions (if any) → resolved project instruction target `### Architecture Decisions`
    - Dev rules (if configured) → `.prizmkit/rules/<layer>-rules.md` (with `root.prizm` `RULES:` pointer)
    - Project brief → `.prizmkit/plans/project-brief.md`
    - 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/architecture-decisions.md

@@ -24,15 +24,9 @@ After Phase 2 (Confirm constraints and tech assumptions), before Phase 3 (Captur
 
 ## How to Capture
 
-1. **Detect platform** — determine which project instruction file to update:
-   - If `.prizmkit/manifest.json` exists, read `platform` and use it as the source of truth.
-   - `codex` → append to `AGENTS.md`
-   - `claude` → append to `CLAUDE.md`
-   - `codebuddy` → append to `CODEBUDDY.md`
-   - `all` → append to all three files. 
-   - If no platform can be determined, skip (no project instruction file).
-
-2. **Check for existing section** — read the target file and look for `### Architecture Decisions` heading:
+1. **Use the resolved project instruction target** — consume the exact current-host target already selected by `SKILL.md` before project-convention discovery. Do not redetect the host, reinterpret manifest identity, or choose from named platform files inside this reference. If the target was not resolved, return to the parent Skill's current-host resolution rule; ask the user when evidence is missing or ambiguous rather than guessing or silently skipping.
+
+2. **Check for existing section** — read the resolved target and look for `### Architecture Decisions` heading:
    - If heading exists → append new entries below it (avoid duplicates with existing entries)
    - If heading does not exist → create it at the end of the file
 
@@ -44,7 +38,7 @@ After Phase 2 (Confirm constraints and tech assumptions), before Phase 3 (Captur
    - Monorepo structure: shared types between frontend and backend
    ```
 
-4. **User confirmation** — before writing, show the collected decisions and ask:
-   > "These architecture decisions were identified during planning. Record them to [AGENTS.md / CLAUDE.md / CODEBUDDY.md]? (Y/n)"
+4. **User confirmation** — before writing, show the collected decisions and the exact resolved target path, then ask:
+   > "These architecture decisions were identified during planning. Record them in `<resolved-project-instruction-target>`? (Y/n)"
 
    If user declines, skip without further prompting.

package/bundled/skills/app-planner/references/frontend-design-guide.md

@@ -2,7 +2,7 @@
 
 > Create distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics.
 
-**app-planner context**: In the planning phase, use this guide to establish **design direction decisions** (aesthetic tone, typography approach, color strategy, layout philosophy). Do NOT produce CSS, code, or implementation artifacts — capture the design direction as decisions in the project instruction file (`AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md`). Downstream implementation skills will consume these decisions when building features.
+**app-planner context**: In the planning phase, use this guide to establish **design direction decisions** (aesthetic tone, typography approach, color strategy, layout philosophy). Do NOT produce CSS, code, or implementation artifacts — capture the design direction in the current session's resolved project instruction target selected by `SKILL.md`. Do not redetect a platform or choose a named file in this reference. Downstream implementation skills will consume these decisions when building features.
 
 Load this guide **only when the feature involves frontend/UI work**. Skip for backend-only or infrastructure features.
 

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

@@ -14,7 +14,7 @@ Planning artifacts may be gitignored, untracked, or absent from staged and unsta
 
 - Project brief: `.prizmkit/plans/project-brief.md`
 - Draft brief when present: `.prizmkit/plans/project-brief.draft.md`
-- Project instruction files selected by `.prizmkit/manifest.json`: `AGENTS.md`, `CLAUDE.md`, `CODEBUDDY.md`
+- The exact project instruction target selected for the current session, limited to sections written or changed by app-planner
 - Generated rule files: `.prizmkit/rules/<layer>-rules.md`
 - Prizm docs root pointer: `.prizmkit/prizm-docs/root.prizm` `RULES:` line only
 - In-memory answers, draft brief data, rules configuration answers, or section snapshots captured before writes
@@ -32,7 +32,7 @@ Do not rely on `git status`, `git diff`, or `git diff --cached` to decide whethe
 ## Source-of-Truth Map
 
 - `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, and architecture decisions are source sections in `AGENTS.md`, `CLAUDE.md`, or `CODEBUDDY.md`. If a fix changes user-approved wording or meaning, ask for user confirmation before rewriting.
+- 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.
 - `root.prizm` fixes are limited to correcting or adding the `RULES:` pointer line; do not rewrite unrelated root content.
 

package/bundled/skills/app-planner/references/infrastructure-convention-discovery.md

@@ -4,7 +4,7 @@ Detailed Q&A flows for database, deployment, and cloud services conventions duri
 
 ## Infrastructure Section Check
 
-Check `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` for `### Infrastructure` section:
+Check the current session's resolved project instruction target for a `### Infrastructure` section. Consume the exact target selected by `SKILL.md`; do not redetect a platform or choose a named file in this reference:
 
 - If `### Infrastructure` section does not exist → this project was not initialized with prizmkit-init's Phase 4.6. Treat as if both database and deployment are undecided — run full inquiry below.
 - If `<!-- infrastructure: deferred -->` → user explicitly skipped at init time. Ask: "During project init you deferred infrastructure decisions. Would you like to configure them now?" (options: "Yes — configure now (Recommended)", "Skip — decide later")
@@ -105,4 +105,4 @@ After infrastructure inquiry, update the `### Infrastructure` section in the pro
 <!-- If user picked "None" in Round 1, replace this block with: cloud-services: none -->
 ```
 
-Items still marked "Skip — decide later" remain as `<!-- [topic]: deferred -->` in the selected project instruction file for `prizmkit-deploy` to pick up later.
+Items still marked "Skip — decide later" remain as `<!-- [topic]: deferred -->` in the resolved project instruction target for `prizmkit-deploy` to pick up later.

package/bundled/skills/app-planner/references/project-conventions-discovery.md

@@ -55,5 +55,5 @@ Then ask in text: "Anything I missed that you'd like to standardize?" — if the
 
 ## After Discovery
 
-→ Save resolved convention meanings to `AGENTS.md` / `CLAUDE.md` / `CODEBUDDY.md` under `### Project Conventions` (one standalone domain rule per bullet). Do not copy raw answers, option labels, recommendation markers, question IDs, or dialogue provenance.
+→ Save resolved convention meanings to the current session's resolved project instruction target under `### Project Conventions` (one standalone domain rule per bullet). Consume the target selected by `SKILL.md`; do not redetect a platform or choose a named file in this reference. Do not copy raw answers, option labels, recommendation markers, question IDs, or dialogue provenance.
 → Output format will naturally vary per project — that is the intended behavior