@opengsd/gsd-path 1.1.0 → 1.2.0

package/skills/gsd-path/scripts/worktree_paths.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# gsd-path project runtime
+"""Placement shared by task isolation, verification, and integration."""
+
+import sys
+
+# Runtime helpers must not modify their immutable installation.
+sys.dont_write_bytecode = True
+
+import hashlib
+import json
+import os
+import tempfile
+from pathlib import Path
+
+try:
+    import _common
+except ImportError:
+    from scripts import _common
+
+
+def _git(primary: Path, *args: str) -> str:
+    result = _common.run_git(primary, *args)
+    if result.returncode:
+        raise ValueError(result.stderr.strip() or "cannot inspect worktree placement")
+    return result.stdout.rstrip("\n")
+
+
+def _identity(path: Path) -> str:
+    return hashlib.sha256(os.fsencode(path)).hexdigest()
+
+
+def _workspace(primary: Path, pin: bool) -> Path:
+    common = Path(_git(primary, "rev-parse", "--git-common-dir"))
+    common = (primary / common).resolve()
+    identity = _identity(primary)
+    receipt = common / "gsd-path" / "workspaces" / f"{identity}.json"
+    try:
+        data = json.loads(receipt.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        pass
+    else:
+        if (not isinstance(data, dict) or data.get("primary") != str(primary)
+                or not isinstance(data.get("root"), str)
+                or not Path(data["root"]).is_absolute()):
+            raise ValueError(f"invalid worktree placement receipt: {receipt}")
+        return Path(data["root"])
+
+    root = Path(os.environ.get("GSD_PATH_WORKTREE_ROOT") or Path.home() / ".gsd-path" / "projects").expanduser()
+    if not root.is_absolute():
+        raise ValueError("GSD_PATH_WORKTREE_ROOT must be absolute")
+    root = root.resolve()
+    parent = root
+    while not parent.exists():
+        parent = parent.parent
+    ancestor = _common.run_git(parent, "rev-parse", "--git-common-dir")
+    same_repository = (
+        ancestor.returncode == 0
+        and (parent / ancestor.stdout.strip()).resolve() == common
+    )
+    if root.is_relative_to(primary) or same_repository:
+        raise ValueError(f"managed worktree root must be outside this repository's worktrees: {root}")
+    workspace = root / _identity(common) / identity
+    if pin:
+        receipt.parent.mkdir(parents=True, exist_ok=True)
+        fd, temporary = tempfile.mkstemp(dir=receipt.parent)
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump({"primary": str(primary), "root": str(workspace)}, handle)
+            try:
+                os.link(temporary, receipt)
+            except FileExistsError:
+                return _workspace(primary, False)
+        finally:
+            os.unlink(temporary)
+    return workspace
+
+
+def worktree_path(primary: Path, kind: str, name: str, *, pin: bool = False) -> Path:
+    primary = primary.resolve()
+    if kind not in {"task", "verify", "integrate"} or not name or Path(name).name != name or name in {".", ".."}:
+        raise ValueError("invalid managed worktree kind or name")
+    legacy = (primary.parent / f".{primary.name}-gsd-path-integrate-{name}"
+              if kind == "integrate" else primary.parent / f"{primary.name}.gsd-path" / kind / name)
+    branch = f"refs/heads/gsd-path-{kind}/{name}"
+    records = _git(primary, "worktree", "list", "--porcelain", "-z").split("\0\0")
+    for record in records:
+        fields = record.split("\0")
+        if f"worktree {legacy}" in fields and f"branch {branch}" in fields:
+            return legacy
+    # Keep collision checks and missing-directory recovery at the old location.
+    if os.path.lexists(legacy):
+        return legacy
+    return _workspace(primary, pin) / kind / name

package/skills/gsd-path/templates/skeptic.md

@@ -1,7 +1,7 @@
 # Skeptic — wave <N>, cycle <C>
 
 <!-- Written by one finding-skeptic child. Advisory to fix-task batching
-     only: the inherit reviewer owns Wave verdict. -->
+     only: the canonical reviewer owns Wave verdict. -->
 
 - Criterion: <the failed criterion, verbatim from the lens file>
 - Criterion locator: <t001_ac2 | t001_files | sc3>

package/skills/gsd-path/templates/task.md

@@ -8,6 +8,8 @@ agent: null         # orchestrator-owned: set at dispatch
 base: null          # orchestrator-owned: clean layer SHA for isolated Verify
 worktree: null      # orchestrator-owned: isolated task worktree while active
 task_branch: null   # orchestrator-owned: gsd-path-task/<id> while parallel; null when serial
+# Optional explicit dispatch overrides: model: <advertised slug|inherit>
+# effort: <advertised effort|inherit>
 files:              # every file this task may touch — dispatch checks overlap
   - <path>
 ---

package/skills/gsd-path/templates/wave-panel.md

@@ -1,6 +1,6 @@
 # Panel — wave <N>, cycle <C>
 
-<!-- Written by one review-panel child. Advisory only: the inherit reviewer
+<!-- Written by one review-panel child. Advisory only: the canonical reviewer
      owns Wave verdict. Kind criterion may be presented to the user when
      Severity is high; preference stays a warning. -->
 

package/skills/gsd-path-build/SKILL.md

@@ -3,6 +3,8 @@ name: gsd-path-build
 description: Execute or resume an approved GSD Path plan with isolated task worktrees, deterministic commits, and independent wave review. Use only when the user explicitly invokes $gsd-path-build or an active $gsd-path router explicitly routes to this phase.
 ---
 
+Before executing project helpers, read [runtime selection](references/runtime-selection.md).
+
 # GSD Path Build Orchestrator
 
 Orchestrate coders, task landing, and reviewers from the main conversation.
@@ -98,6 +100,11 @@ rule; never invoke an explicit-only sibling skill yourself.
 checkpoint `.project/` records uses this helper. Record the exact full HEAD
 before the first metadata change in that checkpoint, then run:
 
+Explicit configuration edits in `.project/config.json` and
+`.project/model-policy.json` are expected bookkeeping. Include them in the next
+normal checkpoint before a clean dispatch base; they may remain pending while
+an already dispatched task lands. Existing model selections stay pinned.
+
 ```text
 python3 <absolute isolation.py> checkpoint \
   --repo <absolute primary> \

package/skills/gsd-path-build/references/build-native.md

@@ -37,7 +37,9 @@ its sidecar, copies it to the canonical path, retires the sidecar, and only
 after every lens settles concludes: a passing cycle with no panel is
 checkpointed; with a panel configured (`panel_required: true`) run `panel
 --wave <N> --cycle <C> --advertised <slugs> [--parent-slug <slug>]
---child-command '<owner command with {model}>'`, which resolves the panel,
+--child-command '<owner command>'`, using the
+[model-policy CLI contract](model-policy.md#cli-lifecycle). The panel command
+resolves membership,
 persists a skipped receipt or runs one panelist per family in its own
 sidecar, merges the family files, and makes the single on-pass checkpoint;
 `blocked` returns the `review_findings.py collect` grouping; when its
@@ -53,7 +55,9 @@ The driver never writes a `verify-only` file (`status: not-applicable`);
 approved artifacts or the user, record it with `answer --task-id <id>
 --answer '<answer> — <citation>'`, and call `round` again, which redispatches
 the retained isolate; `blocked` names the task, reason, and output and leaves
-the isolate in place — apply the recovery, retry, or plan-defect procedure in
+an existing isolate in place. A model-selection rejection before launch creates
+no isolate; follow the [model-policy contract](model-policy.md). For other
+blocks, apply the recovery, retry, or plan-defect procedure in
 steps 1–2 by hand, then call `round` again. The driver counts dispatches per
 task per milestone and stops at `--max-attempts` (default 2: the first
 dispatch plus this contract's one logged redispatch); owner token limits, when
@@ -351,12 +355,16 @@ dispatch contract and perform steps 1–5 by hand.
      against that evidence and the diff; anything it cannot
      confirm from them is a finding, not a pass. Never spawn a review panel
      at `verify-only`.
-   - After the canonical inherit reviewer (or orchestrator-written
+   - After the canonical reviewer (or orchestrator-written
      `verify-only` file) is collected, run the optional review panel only
      for `full` and `deep`. Inspect advertised model slugs and run
      `python3 <absolute review_panel.py> resolve --plan <absolute PLAN.md>
      --intent <absolute INTENT.md> --advertised <comma slugs>
-     --parent-slug <current model slug when known>` and `--charter
+     --parent-slug <current model slug when known>
+     --exclude-family <known canonical-reviewer family>`; repeat
+     `--exclude-family` for every known parent and canonical-reviewer family,
+     including all deep review lenses, before persisting the roster. Omit
+     unknown identities. Also pass `--charter
      <absolute .project/CHARTER.md>` when that file exists. `status: off`
      continues with no current-cycle panel artifact. For `skipped`,
      persist the helper's exact JSON stdout as
@@ -368,16 +376,16 @@ dispatch contract and perform steps 1–5 by hand.
      the reviewer role in wave-panel mode, the wave-panel template, and the
      exact helper-returned model slug when the host advertises model
      selection. On `deep`, each panel brief is the adversarial lens only.
-     Never override the model on the canonical reviewer. Each child stages
+     Resolve model choices through the dispatch model-policy contract. Each child stages
      its family file in its own verify sidecar from `isolate-verify`
      (`--name wave-<N>-cycle-<C>-panel-<family>`); the parent validates
      those files and runs `python3 <absolute review_panel.py> merge --kind
      wave --wave <N> --cycle <C> --inputs <family files> --output
      <absolute .project/review/wave-N.cycleC.panel.md> --mode
-     <detected|named>`. The inherit reviewer remains the only Wave verdict.
+     <detected|named>`. The canonical reviewer remains the only Wave verdict.
      Do not average panel findings into that verdict or auto-create fix
      tasks from preference findings.
-   - After the canonical inherit reviewer file (and each deep lens file) is
+   - After the canonical reviewer file (and each deep lens file) is
      on the primary path, run
      `python3 <absolute check_handoffs.py> wave --repo <absolute primary>
      --review <canonical wave-review path>`. A non-zero exit is a blocked

package/skills/gsd-path-build/references/dispatch.md

@@ -7,10 +7,7 @@ use exactly one matching branch:
 - A `spawn_agent` tool exposing `task_name`, `agent_type`, and `fork_turns` is
   Codex. Use `fork_turns: "none"`; coders use the built-in `worker` type and
   every other role uses `default`. Reuse a completed logical target with
-  `followup_task`. For Codex reasoning effort, use `high` for the portable
-  `heavy` tier and `low` for the portable `light` tier; leave reasoning effort
-  unset for the session-default tier, and never pass `heavy` or `light` as a
-  literal Codex value.
+  `followup_task`.
 - A `spawn_agent` tool without those Codex fields is Zed. Spawn one isolated,
   full-capability child per brief. Zed children are not resumable, so retries
   use a fresh child and a complete prompt.
@@ -26,7 +23,7 @@ use exactly one matching branch:
   the complete new prompt for later work. Wait for a colliding active child and
   collect results with `wait_commands_or_subagents`.
 - A `Task` tool advertising the custom `gsd-path` subagent is Cursor. Use that
-  model-inheriting, full-capability child. Resume it by returned agent ID when
+  full-capability child. Resume it by returned agent ID when
   available; otherwise retry with a fresh child and a complete prompt.
 - A `Task` tool advertising the built-in `general` subagent is OpenCode. Use
   that child; if an installed OpenCode v2 host exposes the renamed `subagent`
@@ -65,20 +62,10 @@ For every branch:
 - Resolve the phase's linked role brief to an absolute path, include it in the
   prompt, and require the child to read it before acting. The role brief
   supplies the read-only boundary for auditors and reviewers.
-- Tier hints: use the portable `heavy` tier for `plan`, `plan_patch`, `decide`,
-  and `roadmap`, the portable `light` tier for `inspect_docs` and `docs_audit`,
-  and the session-default tier for every other role. Apply the Codex mapping
-  above when its schema advertises reasoning-effort selection. On every other
-  host, use only an exact native equivalent advertised by that host; otherwise
-  do not override the model or reasoning effort. The only exception is a
-  review-panel child: when the host advertises model selection, pass the exact
-  slug returned by `scripts/review_panel.py resolve` for that family. Never
-  override the model on the canonical reviewer, planner, coder, or any other
-  role.
-  Host isolation: none. The child's working directory is the exact absolute
-  root GSD Path supplied; a host SHA checkout or extra worktree is a contract
-  failure. Never ask the host to create a worktree. Give the child the exact
-  repository or linked-worktree root supplied by GSD Path.
+- Model selection: before every child launch or continuation, follow
+  [the model-policy contract](model-policy.md) and apply its recorded
+  native arguments. It owns defaults, project settings, task overrides,
+  capability failures, and reassignment. Host isolation: none. Use the exact GSD Path supplied root; create no extra checkout.
 - Send a self-contained prompt with absolute input, template, and output paths
   plus the child's bounded responsibility. Every brief also names the absolute
   `AGENTS.md` and `WORKFLOW.md` paths (or explicitly says they are absent), the

package/skills/gsd-path-build/references/jev-review.md

@@ -0,0 +1,82 @@
+# Optional Jev evidence screening
+
+Jev screens selected criterion/evidence pairs for a wave or final reviewer.
+It is disabled by default. Normal Path review needs no account, API key, SDK,
+or network access. This helper uses Python's standard library.
+
+## Enable or disable
+
+Set these environment variables in the session that launches the reviewing
+agent; child agents must inherit them to use Jev:
+
+| Variable | Value |
+| --- | --- |
+| `GSD_PATH_JEV` | Exactly `1` enables screening. Unset it to disable. |
+| `TYPESAFE_API_KEY` | Your TypeSafe API key, supplied through the environment. |
+| `GSD_PATH_JEV_TIMEOUT_SECONDS` | Positive finite seconds chosen by the owner for the HTTP socket timeout. There is no default. |
+
+Enabling this option permits the selected criterion and evidence text to be
+sent to TypeSafe's hosted API. Supply only material authorized for that service.
+Do not include credentials, environment dumps, or unrelated repository content.
+Having a key alone does not enable Jev. Do not put keys in commands or artifacts.
+
+## Reviewer procedure
+
+1. Use only still-uncovered criteria from the assigned wave/final review and
+   the corresponding evidence already available in the supplied verify sidecar.
+   Keep existing rules for isolated evidence, command reuse, and provenance.
+2. Pass JSON through stdin to `python3 -B <absolute skill scripts/jev_review.py>`
+   from that sidecar. Resolve the helper as `../scripts/jev_review.py` relative
+   to this reference directory. Do not create another project report. The input
+   has exactly this shape; replace the illustrative revision and contents:
+
+   ```json
+   {
+     "reviewed_head": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+     "items": [
+       {
+         "id": "T001-AC1",
+         "criterion": "Reject an empty name.",
+         "evidence": "Recorded isolated Verify: test_empty_name passed."
+       }
+     ]
+   }
+   ```
+
+   Use the full review SHA supplied by the orchestrator, unique nonempty item
+   IDs, verbatim criterion text, and selected evidence text. Empty evidence is
+   allowed. The SHA is caller-supplied context; the helper does not prove Git
+   ancestry or that the text actually came from that revision.
+3. Read the JSON status. `disabled` means ordinary review. `unavailable` means
+   ordinary review with the explicit reason recorded in the assigned artifact.
+   Neither is a failed criterion. The helper exits zero for these optional
+   outcomes and makes no automatic retries. Correct invalid input/configuration
+   before an explicit retry; keep a service failure visible and continue review.
+4. For `ok`, inspect per-item `supported`, `partial`, `unsupported`, or `unclear`
+   answers, their probabilities, and confidence. Independently examine suggested
+   gaps under the existing rubric. A Jev answer is neither executable evidence
+   nor an independent review verdict. It cannot satisfy or waive a criterion,
+   change a gate, select a route, or authorize publication.
+5. Keep the advisory JSON receipt in the assigned review artifact's notes or
+   evidence prose, outside fixed-format verdict fields. An `ok` receipt includes
+   the supplied revision, SHA-256 of the exact canonical request, versioned model,
+   item IDs and answers, and token usage. An `unavailable` receipt includes the
+   reason and, only after request construction, the revision and request hash;
+   it has no model, answers, or usage. A `disabled` receipt contains only the
+   status and advisory marker. Retain the selected input with that evidence if it
+   is not already reconstructible from cited sources. Keep all canonical verdicts and template
+   structure unchanged. Reuse the recorded advisory when its exact request and
+   review revision remain unchanged; skip screening for a reused proven review.
+
+## Service behavior
+
+The helper calls only `https://api.typesafe.ai/v1/systemone` with the documented
+version `jev-1.13.0`. It does not follow redirects, echo provider error bodies,
+write files, or install packages. Missing keys/timeouts, HTTP and network errors,
+and invalid input/responses return `unavailable`. There is no confidence cutoff:
+the existing reviewer owns acceptance. Real model accuracy and savings must be
+evaluated on chosen evidence before relying on this advisory signal.
+
+Sources: [HTTP API](https://docs.typesafe.ai/api),
+[models](https://docs.typesafe.ai/models),
+[confidence](https://docs.typesafe.ai/confidence).

package/skills/gsd-path-build/references/model-policy.md

@@ -0,0 +1,139 @@
+# Dispatch model policy
+
+Before native dispatch, run the bundled `scripts/model_policy.py`. CLI dispatch
+uses the same resolver inside `dispatch_driver.py`. The helper owns model and
+effort decisions; apply its output instead of choosing again in prose.
+
+## Project choices
+
+Use `<repo>/.project/model-policy.json`, including when the active track is
+`.project/next`. This file owns project overrides. It is not phase status.
+No file is required to retain existing behavior. `path config` can also set user
+defaults in `~/.gsd-path/config.json` under `models`. Project common roles override
+user host and common roles. Within each scope, host roles override common roles.
+Task overrides still win, and recorded assignments stay pinned.
+
+```json
+{
+  "roles": {"coder": {"model": "inherit"}},
+  "hosts": {"codex": {"plan": {"effort": "high"}}}
+}
+```
+
+Values are exact advertised model/effort strings or `inherit`. This example
+illustrates configuration; it is not a cost-saving preset. Set concrete models
+only from the current host's advertised choices. Host-specific role settings
+override common role settings. Task settings override both, independently for
+model and effort; omitted fields retain the next applicable value. Explicit
+`inherit` removes that field's override. There are no automatic fallbacks.
+
+Role keys are `coder`, `reviewer` (wave, final, and gap review), `review_panel`,
+`skeptic`, `inspect_codebase`, `inspect_docs`, `docs_audit`, `research`, `decide`,
+`roadmap`, `plan`, and `plan_patch`. Use the logical task name as the assignment,
+not as the role. Keep each panel family and review lens a distinct assignment.
+
+The helper retains heavy effort hints for plan, plan_patch, decide, and roadmap;
+light hints for inspect_docs and docs_audit; otherwise effort inherits. Codex
+maps these hints to high/low. Other hosts use only advertised equivalents.
+Hints are conditional; unsupported explicit settings stop the affected child.
+
+Coders may have scalar `model:` and `effort:` fields in their task frontmatter.
+These are part of the approved task contract. Pass the task file with `--task`.
+For other roles, pass assignment-specific `--model` or `--effort` when the owner
+explicitly overrides the role choice. Coder settings do not affect reviewers.
+
+## Advertised capabilities
+
+Capture the current child tool's schema and advertised choices in a JSON file
+outside the product tree. For each supported control, provide its native field,
+allowed values, and, for CLI dispatch, its documented argument template. Omit
+unsupported controls. The values below are fixture examples, not a host catalog:
+
+```json
+{
+  "host": "codex",
+  "model": {"field": "model", "values": ["example-model"],
+            "args": ["--model", "{value}"]},
+  "effort": {"field": "reasoning_effort", "values": ["low", "high"],
+             "args": ["-c", "model_reasoning_effort={value}"]}
+}
+```
+
+`effort_hints` may map heavy/light to exact advertised equivalents. Supply
+`inherited_model` only when the host exposes its identity. Never infer models,
+fields, or CLI flags from a host name. Every existing host uses this contract,
+including hosts with no model or effort controls. Their explicit unsupported
+settings block; their default inheritance remains usable.
+
+## Native lifecycle
+
+Resolve the bundled helper to an absolute path. Use one record under the Git
+common directory's `gsd-path/model-selection/` directory per assignment. Scope
+the path and `--scope` to the milestone, active/lookahead track, and review cycle
+where applicable; later work must not reuse an earlier record.
+
+```text
+python3 -B <helper> resolve --repo <primary> --scope <milestone/track/cycle> --assignment <logical-name> --role <role> --record <absolute-record> --capabilities <advertised-json>
+```
+
+Only `status: ready` authorizes launch. Apply `selection.native` exactly to
+the advertised child tool, preserving the host adapter's other controls and
+GSD Path task isolation. The recorded selection applies to a fresh child too.
+If an existing child is still active, reattach or send its continuation;
+resolving again does not authorize launching a second copy. When a host cannot
+change model/effort on a resumed child, a changed selection requires a fresh
+child after terminal completion of the earlier one.
+
+After terminal completion, release the assignment with `release` using the
+same identity arguments and `--terminal-result <host-completion-evidence>`.
+To change the selection, use `reassign` with the same identity, current
+capabilities, explicit model/effort changes, and `--ruling <verbatim-owner-ruling>`.
+It requires an inactive assignment and preserves prior selection history.
+Resolve again before starting the replacement. A project-policy edit alone
+does not change an existing selection. Task-contract edits still require their
+legal pipeline path.
+
+For panel children, first resolve membership with `review_panel.py resolve`,
+passing `--parent-slug` when known and repeating `--exclude-family` for every
+known parent and canonical-reviewer family (including all deep review lenses).
+Apply these exclusions before persisting membership. Detected membership skips
+excluded families; explicitly named conflicts block. Pass its selected model through `--panel-model`, and pass `--panel-family` plus
+`--exclude-family` for known parent and
+canonical-reviewer families. Persist and reuse the panel roster. Policy cannot
+waive family independence or change canonical review authority. A changed
+panel roster requires a new legal review assignment.
+
+Requested controls are durable evidence. When the host hides the inherited
+model identity, exact effective-model continuity across fresh children remains
+unproven; report that limitation rather than asserting an identity.
+
+## CLI lifecycle
+
+Pass `--model-capabilities <advertised-json>` to the driver. Commands use whole
+argument slots `{model_args}` and `{effort_args}`; the resolver expands these
+to argument arrays. They are not shell substitutions. Remove fixed model and
+effort flags when using these slots; conflicting controls block dispatch.
+Commands with explicit policy choices must expose the corresponding slots,
+including when an explicit choice is `inherit`. Unconfigured legacy commands
+without a capability file retain their existing behavior.
+An existing legacy assignment with no recorded selection keeps its saved
+command across retries, even if project policy or capabilities are later added.
+It cannot use `reassign-model`; model controls require a new explicit assignment.
+
+Review and skeptic commands accept `--model` and `--effort` for that assignment.
+For distinct panel families or review lenses, pass `--model-overrides <json>`:
+a mapping from exact logical assignment names to model/effort objects. Each
+entry applies only to its named assignment; conflicting explicit inputs block.
+A common panel model must satisfy every selected family, so use these scoped
+overrides when families need different models. Family checks remain mandatory.
+Coders read their task overrides. Panels with capabilities use the argument
+slots; legacy panel commands may retain their existing `{model}` placeholder.
+
+The driver persists selection before launch and retains it on retry. Use
+`dispatch_driver.py reassign-model --repo <primary> --task-id <logical-name>
+--model-capabilities <advertised-json> --model <slug> --ruling <owner-ruling>`
+for an inactive unfinished assignment. Finished work and pinned panel rosters
+require a new legal assignment. Earlier attempt evidence is retained.
+
+Compare total cost only with observed usage and outcomes, including retries.
+These controls do not establish cost savings, pricing, or quality rankings.

package/skills/gsd-path-build/references/reviewer-panel.md

@@ -13,5 +13,5 @@ Use only wave-panel.md. Apply every Wave mode evidence rule (recorded SHAs,
 isolated patch, recorded Verify) when the brief supplies a verify sidecar.
 On a `deep` wave the brief is the adversarial lens only. Record findings
 the same way as plan panel mode. Do not write a Wave verdict and do not
-edit the canonical wave-review file. The inherit reviewer remains the only
+edit the canonical wave-review file. The canonical reviewer remains the only
 pass/fail.

package/skills/gsd-path-build/references/reviewer.md

@@ -32,6 +32,8 @@ Resolve sibling links against this role file's directory.
 
 ## Rules
 
+- When `GSD_PATH_JEV=1`, wave and final reviewers follow the optional
+  [Jev evidence screening procedure](jev-review.md) for uncovered criteria.
 - Review written expectations, not preferences or alternate designs.
 - Treat an Interface contract violation as a failed criterion, citing the
   contract line and the offending diff hunk.

package/skills/gsd-path-build/references/runtime-selection.md

@@ -0,0 +1,25 @@
+# Project runtime selection
+
+Before running a project runtime helper, check for
+`<absolute-project>/.gsd-path/runtime.json`. When present, run the stable launcher:
+
+```sh
+python3 -B <absolute-project>/.gsd-path/status_runtime.py --repo <absolute-project> --runtime-path
+```
+
+Use `python` only when it is the compatible Python 3.9+ interpreter. A failure
+stops helper execution: follow the exact-version restore action in the error.
+Do not install, upgrade, or fall back to the current plugin's runtime implicitly.
+
+The returned directory is the verified Project runtime. Resolve helper names
+present in its `manifest.json` from that directory, including status, state,
+isolation, integration, archive, recovery, build-state, final-verification, and guard helpers.
+The workflow runner resolves its subprocess helpers from this same directory;
+helper imports stay within the selected runtime. This rule overrides
+references to bundled copies of those helpers. Other skill helpers, templates,
+and role briefs remain in the installed skill bundle. Pass `-B` to Python helper
+invocations so execution does not create bytecode in the runtime store.
+
+With no declaration, retain the legacy helper lookup. An existing
+`.gsd-path/runtime/` requires the explicit `--runtime-migrate --project PATH`
+operation before adopting external storage; review the resulting Git diff.

package/skills/gsd-path-build/scripts/_common.py

@@ -9,6 +9,11 @@ consuming module keep working.
 
 from __future__ import annotations
 
+import sys
+
+# Runtime helpers must not modify their immutable installation.
+sys.dont_write_bytecode = True
+
 import json
 import os
 import re

package/skills/gsd-path-build/scripts/archive_milestone.py

@@ -16,6 +16,9 @@ import re
 import shutil
 import subprocess
 import sys
+
+# Runtime helpers must not modify their immutable installation.
+sys.dont_write_bytecode = True
 from contextlib import contextmanager
 from datetime import date
 from pathlib import Path, PurePosixPath
@@ -1743,6 +1746,12 @@ def require_clean_active_root(active_root: Path, archive: Path) -> None:
     carried_forward = pending_ruling_count(archived_audit)
     # Persistent project metadata ships but never archives with a milestone.
     allowed = {"STATE.md", "REPOSITORY.md", "archive", "LESSONS.md", "next"}
+    for name in ("config.json", "model-policy.json"):
+        path = active_root / name
+        if path.exists() or path.is_symlink():
+            if path.is_symlink() or not path.is_file() or path.stat().st_nlink != 1:
+                raise ArchiveError(f"project settings must be a regular unlinked file: {path}")
+            allowed.add(name)
     if (active_root / "CHARTER.md").is_file():
         # Program flow: these persist at the .project/ top level.
         allowed |= {"CHARTER.md", "ROADMAP.md", "SYNTHESIS.md"}
@@ -1808,6 +1817,7 @@ def prepared_transaction(
     repo: Path,
     phases: Sequence[str],
     must_be_uncommitted: bool = False,
+    *, historical: bool = False,
 ) -> tuple:
     project = repo.resolve()
     active_root = require_project_layout(project)
@@ -1816,7 +1826,7 @@ def prepared_transaction(
     state, _, loaded_state_path = strict_state(project)
     if loaded_state_path.resolve() != state_path.resolve():
         raise ArchiveError("strict STATE.md loader returned an unexpected path")
-    require_transaction_context(project, state, phases)
+    require_transaction_context(project, state, phases, historical=historical)
 
     configured = state.archive
     if configured is None:
@@ -1880,10 +1890,11 @@ def require_canonical_commit_body(
         raise ArchiveError(f"{label} commit body does not match required fields")
 
 
-def find_ship_commit(project: Path, archive_name: str) -> str:
+def find_ship_commit(project: Path, archive_name: str, *, historical: bool = False) -> str:
     expected_subject = ship_subject(archive_name)
     log = require_git_success(
-        run_git(project, "log", "--first-parent", "--format=%H%x00%s", "HEAD"),
+        run_git(project, "log", *([] if historical else ["--first-parent"]),
+                "--format=%H%x00%s", "HEAD"),
         "inspect HEAD history for the ship commit",
     )
     matches = []
@@ -1926,19 +1937,22 @@ def validate_shipped_roadmap(text: str, state: PipelineState, archive: str) -> N
         raise ArchiveError("ROADMAP.md must record Status: shipped and the exact Archive")
 
 
-def validate(repo: Path) -> dict:
+def validate(repo: Path, *, historical: bool = False) -> dict:
     project, _, state, configured, archive, archived_files, reviewed_head = prepared_transaction(
         repo,
         ("shipped",),
+        historical=historical,
     )
     if state.status != "done":
         raise ArchiveError("STATE.md is not shipped/done")
 
-    project_status = require_git_success(run_git(project, "status", "--porcelain"), "inspect worktree status")
+    project_status = require_git_success(
+        run_git(project, "status", "--porcelain", *(["--", ".project"] if historical else [])),
+        "inspect worktree status")
     if project_status:
         raise ArchiveError("ship transaction worktree is not clean")
 
-    ship_commit = find_ship_commit(project, archive.name)
+    ship_commit = find_ship_commit(project, archive.name, historical=historical)
 
     parents = require_git_success(
         run_git(project, "rev-list", "--parents", "-n", "1", ship_commit),

package/skills/gsd-path-build/scripts/build_recovery.py

@@ -3,6 +3,11 @@
 
 from __future__ import annotations
 
+import sys
+
+# Runtime helpers must not modify their immutable installation.
+sys.dont_write_bytecode = True
+
 import json
 import re
 from pathlib import Path

package/skills/gsd-path-build/scripts/build_state.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# gsd-path project runtime
 """Build task readiness, landing reconciliation, and the verify ledger."""
 
 from __future__ import annotations
@@ -7,6 +8,7 @@ import argparse
 import json
 import re
 import sys
+sys.dont_write_bytecode = True
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath