okstra 0.169.1 → 0.170.0

package/runtime/python/okstra_ctl/agent_prompt_cli.py

@@ -41,6 +41,7 @@ from .dispatch_state import (
     DispatchError,
     link_agent_dispatch_result,
     record_verified_agent_dispatch,
+    reject_agent_dispatch_result,
 )
 
 
@@ -110,6 +111,18 @@ def _parser() -> argparse.ArgumentParser:
     )
     record_dispatch.add_argument("--json", action="store_true")
 
+    reject_result = commands.add_parser(
+        "reject-result",
+        help="mark a linked result rejected so a corrective re-dispatch can "
+             "claim its path",
+    )
+    _common_paths(reject_result)
+    reject_result.add_argument("--run-manifest", required=True)
+    reject_result.add_argument("--dispatch-id", required=True)
+    reject_result.add_argument("--superseded-by", required=True)
+    reject_result.add_argument("--reason", required=True)
+    reject_result.add_argument("--json", action="store_true")
+
     link_result = commands.add_parser("link-result")
     _common_paths(link_result)
     link_result.add_argument("--run-manifest", required=True)
@@ -156,6 +169,9 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "record-dispatch":
             _record_dispatch(args)
             return 0
+        if args.command == "reject-result":
+            _reject_result(args)
+            return 0
         _link_result(args)
         return 0
     except (
@@ -192,6 +208,20 @@ def _record_dispatch(args: argparse.Namespace) -> None:
     _emit(record, args.json)
 
 
+def _reject_result(args: argparse.Namespace) -> None:
+    project_root = _project_root(args.project_root)
+    row = reject_agent_dispatch_result(
+        project_root=project_root,
+        run_manifest_path=_project_input(
+            project_root, args.run_manifest, "run manifest"
+        ),
+        dispatch_id=args.dispatch_id,
+        superseded_by=args.superseded_by,
+        reason=args.reason,
+    )
+    _emit(row, args.json)
+
+
 def _link_result(args: argparse.Namespace) -> None:
     project_root = _project_root(args.project_root)
     link = link_agent_dispatch_result(

package/runtime/python/okstra_ctl/cmux.py

@@ -199,17 +199,23 @@ def plan_worker_placement(
     return _extend_the_shortest_column(columns)
 
 
-def lead_shrink_points(lead: PaneGeometry, *, target_columns: int) -> int:
-    """How far to push the lead's right border, in the points `pane.resize` takes.
+def lead_resize_points(lead: PaneGeometry, *, target_columns: int) -> int:
+    """How far to move the lead's right border, in the points `pane.resize` takes.
+
+    Signed: positive when the lead is too wide and the border comes in, negative
+    when it is too narrow and the border goes out.
+
+    Both directions are needed. A split halves whatever pane it lands on, and
+    the first worker of every round lands on the lead — so a rule that only ever
+    shrinks leaves that half permanent, and the round after it takes half of
+    what is left. Measured on this display: 215 columns becomes 80, then 40,
+    then 20, until neither the lead nor its workers can be read.
 
     The API's `amount` is points, not cells — measured at this pane's own
-    `cell_width_points`, so passing a column count shrinks by an eighth of the
-    intent on a typical display.
+    `cell_width_points`, so passing a column count moves the border by an eighth
+    of the intent on a typical display.
     """
-    surplus = lead.columns - target_columns
-    if surplus <= 0:
-        return 0
-    return surplus * lead.cell_width_points
+    return (lead.columns - target_columns) * lead.cell_width_points
 
 
 def _holds_an_okstra_surface(
@@ -326,7 +332,7 @@ def spawn_worker_surface(
     surface_uuid = _open_worker_surface(workspace, placement, target)
     run_cmux(["rename-tab", "--surface", surface_uuid, "--title", title])
     _exec_worker(surface_uuid, cwd=cwd, command=command)
-    _shrink_lead_pane(workspace)
+    _size_lead_pane(workspace)
     return surface_uuid
 
 
@@ -530,28 +536,39 @@ def _exec_worker(surface_uuid: str, *, cwd: Path, command: Sequence[str]) -> Non
         raise RuntimeError(started.stderr.strip() or "cmux could not start the worker")
 
 
-def _shrink_lead_pane(workspace: str) -> None:
-    """Give the lead's width to the workers by pushing its right border left.
+def _size_lead_pane(workspace: str) -> None:
+    """Put the lead back on its target width, leaving the rest to the workers.
+
+    Which pane carries the request follows from what `pane.resize` does: it
+    moves the named pane's own border in the direction given. The lead can push
+    its right border out — that is `right` on the lead itself — but it cannot
+    pull that border in, because `left` on the leftmost pane finds no adjacent
+    border to move. Narrowing is therefore the right-hand neighbour's request,
+    and widening is the lead's.
 
-    The lead cannot shrink itself: `pane.resize` moves the named pane's border,
-    so asking the leftmost pane to move `left` fails with no adjacent border and
-    `right` widens it. The neighbour on its right carries the request instead.
+    Run after every worker opens rather than once per round: the split that just
+    happened is what knocked the lead off its width, and no other event does.
     """
     panes = list_panes(workspace)
     lead = _lead_pane(panes)
-    amount = lead_shrink_points(lead, target_columns=LEAD_TARGET_COLUMNS)
-    if amount <= 0:
+    offset = lead_resize_points(lead, target_columns=LEAD_TARGET_COLUMNS)
+    if offset == 0:
         return
     neighbours = [pane for pane in panes if pane.x > lead.x]
     if not neighbours:
         return
+    narrowing = offset > 0
     rpc(
         "pane.resize",
         {
             "workspace_id": workspace,
-            "pane_id": min(neighbours, key=lambda pane: pane.x).pane_id,
-            "direction": "left",
-            "amount": amount,
+            "pane_id": (
+                min(neighbours, key=lambda pane: pane.x).pane_id
+                if narrowing
+                else lead.pane_id
+            ),
+            "direction": "left" if narrowing else "right",
+            "amount": abs(offset),
         },
     )
 

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -19,7 +19,9 @@ from .dispatch_state import (
     append_worker_dispatch as _append_worker_dispatch,
     DispatchError,
     WorkerJob,
+    dispatch_completion_paths as _completion_paths,
     dispatch_mode as _dispatch_mode,
+    dispatch_result_path as _result_path_for_worker,
     LIVENESS_AUDIT_HEARTBEAT,
     LIVENESS_WRAPPER_STATUS,
     load_json_object as _load_json_object,
@@ -41,10 +43,6 @@ from .dispatch_state import (
     worker_state as _worker_state,
     worktree_path as _worktree_path,
 )
-from .final_report_paths import (
-    final_report_data_path as _final_report_data_path,
-    final_report_markdown_path as _final_report_markdown_path,
-)
 from .error_log_write import append_observed
 from .lead_events import LeadEvent, append_lead_event
 from .initial_prompt_materialization import (
@@ -55,6 +53,8 @@ from .initial_prompt_materialization import (
     materialize_initial_prompts,
 )
 from .path_hints import hydrate_active_run_context
+from .schema_excerpt import bundle_excerpt_path, excerpt_version_skew
+from .seeding import installed_version
 from .report_finalize import (
     STEP_VALIDATE_RUN,
     FinalizeContext,
@@ -191,7 +191,7 @@ def build_dispatch_plan(
         default_provider_by_worker_id=dict(default_provider_by_worker_id or {}),
     )
     if jobs_file:
-        jobs = _jobs_from_file(project_root, workspace_root, jobs_file, options)
+        jobs = _jobs_from_file(project_root, workspace_root, jobs_file, manifest, options)
     else:
         jobs = _jobs_from_roster(
             project_root,
@@ -204,6 +204,7 @@ def build_dispatch_plan(
             options,
         )
     _validate_dispatch_prompts(manifest, active_context, jobs)
+    _reject_stale_schema_excerpt(project_root, manifest, jobs)
     return DispatchPlan(
         project_root=project_root,
         workspace_root=workspace_root.resolve(),
@@ -705,6 +706,7 @@ def _jobs_from_file(
     project_root: Path,
     workspace_root: Path,
     jobs_file: Path | None,
+    manifest: Mapping[str, Any],
     options: _BuildOptions,
 ) -> list[WorkerJob]:
     if jobs_file is None:
@@ -712,6 +714,7 @@ def _jobs_from_file(
     return _worker_jobs_from_file(
         project_root,
         jobs_file,
+        manifest=manifest,
         backend=options.default_backend,
         idle_timeout_seconds=options.idle_timeout_seconds,
         default_dispatch_kind=options.dispatch_kind,
@@ -958,13 +961,7 @@ def _retry_from_record(
 def _finish_attempt(plan: DispatchPlan, job: WorkerJob, attempt: int, outcome: WorkerOutcome) -> None:
     settlement = _settle(plan, job, attempt, outcome)
     if settlement.completed:
-        if job.invocation_id:
-            _link_agent_dispatch_result(
-                project_root=plan.project_root,
-                run_manifest_path=plan.manifest_path,
-                dispatch_id=f"{job.invocation_id}:attempt-{attempt}",
-                result_path=job.worker_result_path,
-            )
+        result_link = _link_result(plan, job, attempt)
         post_process = _post_process_report_writer_result(plan, job)
         if not post_process["ok"]:
             reason = _require_string(post_process, "reason")
@@ -990,10 +987,15 @@ def _finish_attempt(plan: DispatchPlan, job: WorkerJob, attempt: int, outcome: W
             plan.team_state_path, job.worker_id, "completed", ""
         )
         _update_dispatch_status(
-            plan.team_state_path, job, attempt, "completed", settlement.note
+            plan.team_state_path,
+            job,
+            attempt,
+            "completed",
+            "; ".join(part for part in (settlement.note, result_link["reason"]) if part),
         )
         details = _result_details(job, attempt, outcome)
         details["postProcessing"] = post_process["steps"]
+        details["resultLink"] = result_link
         if settlement.error_log_append is not None:
             details["errorLogAppend"] = settlement.error_log_append
         _append_event(plan, "worker-result-collected", details)
@@ -1008,6 +1010,43 @@ def _finish_attempt(plan: DispatchPlan, job: WorkerJob, attempt: int, outcome: W
     _append_event(plan, "worker-failed", details)
 
 
+def _link_result(
+    plan: DispatchPlan, job: WorkerJob, attempt: int
+) -> dict[str, Any]:
+    """Bind this result to its verified dispatch, reporting rather than raising.
+
+    Linking is bookkeeping around a dispatch that has already settled, and it
+    used to run before any status was written. A refused link — the live case is
+    a corrective re-dispatch claiming a path the first attempt still owns — threw
+    out of `_finish_attempt`, so nothing transitioned, the row stayed `running`,
+    and the exception reached the caller as exit 2. The next `await` re-read the
+    same terminal sidecar, re-settled the same way, and threw at the same line:
+    a worker with complete artifacts wedged the run permanently, and no amount of
+    waiting could clear it.
+
+    So the settle is written either way and the refusal travels back as data. It
+    is not swallowed: the reason lands in the dispatch row and in the lead event,
+    and the post-hoc validators still require every accepted result to carry a
+    link, so an unlinked result fails where an audit failure belongs rather than
+    by stopping the run mid-phase. `agent-prompt reject-result` is the remedy the
+    refusal names.
+    """
+    link: dict[str, Any] = {"ok": True, "reason": ""}
+    if not job.invocation_id:
+        return link
+    try:
+        _link_agent_dispatch_result(
+            project_root=plan.project_root,
+            run_manifest_path=plan.manifest_path,
+            dispatch_id=f"{job.invocation_id}:attempt-{attempt}",
+            result_path=job.worker_result_path,
+        )
+    except (DispatchError, OSError) as exc:
+        link["ok"] = False
+        link["reason"] = f"result link refused: {exc}"
+    return link
+
+
 def _finish_record(plan: DispatchPlan, record: Mapping[str, Any], outcome: WorkerOutcome) -> None:
     job = _job_from_record(plan.project_root, record)
     _finish_attempt(plan, job, int(record.get("attempt", 1)), outcome)
@@ -1626,17 +1665,48 @@ def _provider_for_worker(
     return worker_id
 
 
-def _result_path_for_worker(worker_id: str, result_path: Path, manifest: Mapping[str, Any], project_root: Path) -> Path:
-    if worker_id != REPORT_WRITER_WORKER_ID:
-        return result_path
-    return _final_report_data_path(_resolve_required_path(project_root, manifest, "expectedReportPath"))
 
 
-def _completion_paths(worker_id: str, result_path: Path, manifest: Mapping[str, Any], project_root: Path) -> tuple[Path, ...]:
-    if worker_id != REPORT_WRITER_WORKER_ID:
-        return (result_path,)
-    data_json = _final_report_data_path(_resolve_required_path(project_root, manifest, "expectedReportPath"))
-    return (data_json, _final_report_markdown_path(data_json), result_path)
+def _reject_stale_schema_excerpt(
+    project_root: Path,
+    manifest: Mapping[str, Any],
+    jobs: Sequence[WorkerJob],
+) -> None:
+    """Refuse to send the report writer at a schema excerpt from another runtime.
+
+    The bundle's `instruction-set/final-report-schema.json` is cut at prep time
+    and never moves again, while validation always runs against the installed
+    schema. A run long enough to straddle a runtime upgrade therefore has the
+    author writing to one contract and the validator reading another — and the
+    only thing that noticed was the renderer, in Phase 6, after the worker had
+    authored the whole report. The two versions are comparable the moment the
+    dispatch is built, and the remedy is the same either way, so it belongs here.
+
+    Only the report writer is stopped: it is the only worker that authors against
+    the excerpt. Re-running bundle prep re-cuts it from the installed schema.
+    """
+    writer = next(
+        (job for job in jobs if job.worker_id == REPORT_WRITER_WORKER_ID), None
+    )
+    if writer is None:
+        return
+    expected = _string_value(manifest.get("expectedReportPath"))
+    if not expected:
+        return
+    excerpt_path = bundle_excerpt_path(_resolve_project_path(project_root, expected))
+    if excerpt_path is None:
+        return
+    installed = installed_version()
+    cut_from = excerpt_version_skew(excerpt_path, installed)
+    if not cut_from:
+        return
+    raise DispatchError(
+        f"the bundle's schema excerpt ({excerpt_path}) was cut from okstra "
+        f"{cut_from} but this runtime is {installed}. The report writer authors "
+        f"against that excerpt and validation runs against the installed schema, "
+        f"so dispatching now spends a full authoring pass on the wrong contract. "
+        f"Re-prepare the task bundle to re-cut the excerpt, then dispatch again."
+    )
 
 
 def _run_dir(plan: DispatchPlan) -> Path:

package/runtime/python/okstra_ctl/dispatch_state.py

@@ -33,6 +33,11 @@ from .agent_invocation import (
     agent_model_assignment_from_payload,
     verify_agent_invocation,
 )
+from .final_report_paths import (
+    final_report_data_path,
+    final_report_markdown_path,
+)
+from .worker_prompt_body import REPORT_WRITER_WORKER_ID
 from .worker_prompt_contract import (
     PromptRecord,
     validate_initial_prompt_records,
@@ -504,9 +509,20 @@ def link_agent_dispatch_result(
             item for item in links
             if isinstance(item, Mapping) and item.get("resultPath") == result_relative
         ]
-        if same_result and any(dict(item) != link for item in same_result):
+        # A superseded link is the record of a result the lead rejected, kept so
+        # the chain shows the corrective round happened rather than hiding it.
+        # It no longer owns the path, so the re-dispatch may claim it.
+        live_conflicts = [
+            item for item in same_result
+            if not item.get("supersededBy") and dict(item) != link
+        ]
+        if live_conflicts:
             raise DispatchError(
-                f"agent result is already linked to another dispatch: {result_relative}"
+                f"agent result is already linked to another dispatch: "
+                f"{result_relative}. If that result was rejected and re-dispatched, "
+                f"record the rejection with `okstra agent-prompt reject-result "
+                f"--dispatch-id {live_conflicts[0].get('dispatchId')} "
+                f"--superseded-by {dispatch_id}` first"
             )
         if any(
             isinstance(item, Mapping)
@@ -523,6 +539,69 @@ def link_agent_dispatch_result(
     return link
 
 
+def reject_agent_dispatch_result(
+    *,
+    project_root: Path,
+    run_manifest_path: Path,
+    dispatch_id: str,
+    superseded_by: str,
+    reason: str,
+) -> dict[str, str]:
+    """Record that a linked result was rejected and re-dispatched.
+
+    The contract tells the lead to re-dispatch a worker whose answer violated the
+    response format, with a correction paragraph appended. That path did not
+    finish: the prompt is immutable and already dispatched, so
+    `--replace-undispatched` refuses (correctly), and a fresh invocation id
+    produces a worker that writes the same result path — where `link-result`
+    refused because the path already belonged to the first dispatch. The worker
+    ran, wrote a good result, and the ledger could not accept it.
+
+    Rejection is a fact worth recording rather than routing around, so it is
+    written rather than allowed implicitly: the first link stays in the ledger
+    marked `supersededBy` with the lead's reason, and only then may the
+    re-dispatch claim the path. Nothing is deleted, so the chain still shows both
+    attempts and why the second exists.
+    """
+    if not superseded_by.strip():
+        raise DispatchError("superseding dispatch ID is required")
+    if not reason.strip():
+        raise DispatchError(
+            "a rejection reason is required — the ledger has to say why a "
+            "returned result was not accepted"
+        )
+    project_root = project_root.resolve()
+    manifest_path = resolve_project_path(
+        project_root, str(run_manifest_path)
+    ).resolve(strict=True)
+    manifest = load_json_object(manifest_path, "run manifest")
+    team_state_path = resolve_required_path(project_root, manifest, "teamStatePath")
+    with _team_state_lock(team_state_path):
+        team_state = load_json_object(team_state_path, "team-state")
+        links = team_state.get("agentResultLinks")
+        if not isinstance(links, list):
+            raise DispatchError("team-state agentResultLinks must be an array")
+        matches = [
+            item for item in links
+            if isinstance(item, Mapping) and item.get("dispatchId") == dispatch_id
+        ]
+        if len(matches) != 1:
+            raise DispatchError(
+                f"expected exactly one agent result link for {dispatch_id}, "
+                f"found {len(matches)}"
+            )
+        row = matches[0]
+        if row.get("supersededBy"):
+            raise DispatchError(
+                f"agent result link is already superseded by "
+                f"{row['supersededBy']}: {dispatch_id}"
+            )
+        row["supersededBy"] = superseded_by
+        row["rejectionReason"] = reason
+        write_json(team_state_path, team_state)
+    return dict(row)
+
+
 def _relative_project_path(project_root: Path, path: Path) -> str:
     try:
         return path.resolve(strict=False).relative_to(project_root).as_posix()
@@ -644,6 +723,54 @@ def missing_completion_paths(job: WorkerJob) -> tuple[Path, ...]:
     return tuple(path for path in job.completion_paths if not path.is_file())
 
 
+def dispatch_result_path(
+    worker_id: str,
+    worker_result_path: Path,
+    manifest: Mapping[str, Any],
+    project_root: Path,
+) -> Path:
+    """What `resultPath` means for this worker.
+
+    For everyone but the report writer it is the worker-result file. The report
+    writer authors three artifacts and its canonical result is the final-report
+    data.json, not its own `.md` pointer — a distinction that is not cosmetic:
+    `dispatch_core` hands `job.result_path` to report finalization as the data
+    path, so a `.md` there is parsed as JSON and a complete report settles
+    `error`.
+
+    This lives beside `worker_jobs_from_file` because both job constructors must
+    apply it. It was `dispatch_core`-private while the roster path applied it and
+    the `--jobs-file` path took whatever the file said, which is how the two
+    produced different jobs for the same worker.
+    """
+    if worker_id != REPORT_WRITER_WORKER_ID:
+        return worker_result_path
+    return final_report_data_path(
+        resolve_required_path(project_root, manifest, "expectedReportPath")
+    )
+
+
+def dispatch_completion_paths(
+    worker_id: str,
+    worker_result_path: Path,
+    manifest: Mapping[str, Any],
+    project_root: Path,
+) -> tuple[Path, ...]:
+    """Every artifact that must exist before this worker counts as done.
+
+    The report writer's three are the data.json, its rendered Markdown sibling,
+    and the worker-result pointer (`prompts/lead/report-writer.md` §"Completion
+    detection"). Same reason as `dispatch_result_path`: both constructors need
+    the same answer.
+    """
+    if worker_id != REPORT_WRITER_WORKER_ID:
+        return (worker_result_path,)
+    data_json = final_report_data_path(
+        resolve_required_path(project_root, manifest, "expectedReportPath")
+    )
+    return (data_json, final_report_markdown_path(data_json), worker_result_path)
+
+
 def validate_initial_prompts(
     manifest: Mapping[str, Any], jobs: Sequence[WorkerJob]
 ) -> None:
@@ -798,6 +925,7 @@ def worker_jobs_from_file(
     project_root: Path,
     jobs_file: Path,
     *,
+    manifest: Mapping[str, Any],
     backend: str,
     idle_timeout_seconds: int,
     default_dispatch_kind: str,
@@ -816,6 +944,7 @@ def worker_jobs_from_file(
         _worker_job_from_file(
             project_root,
             item,
+            manifest=manifest,
             backend=backend,
             idle_timeout_seconds=idle_timeout_seconds,
             dispatch_kind=dispatch_kind,
@@ -831,6 +960,7 @@ def _worker_job_from_file(
     project_root: Path,
     item: Mapping[str, Any],
     *,
+    manifest: Mapping[str, Any],
     backend: str,
     idle_timeout_seconds: int,
     dispatch_kind: str,
@@ -842,16 +972,20 @@ def _worker_job_from_file(
     prompt_path = resolve_project_path(
         project_root, require_string(item, "promptPath")
     )
-    result_path = resolve_project_path(
-        project_root, require_string(item, "resultPath")
-    )
     worker_result_path = resolve_project_path(
         project_root, require_string(item, "workerResultPath")
     )
-    completion_paths = tuple(
-        resolve_project_path(project_root, path)
-        for path in string_list(item.get("completionPaths"))
-    ) or (result_path,)
+    # The file's own `resultPath` / `completionPaths` are advisory: the same
+    # derivation the roster path applies decides them, so a jobs-file dispatch
+    # and a roster dispatch of one worker cannot disagree about which artifact
+    # is the result. A file that names the report writer's `.md` as its result
+    # used to reach report finalization as the data path.
+    result_path = dispatch_result_path(
+        worker_id, worker_result_path, manifest, project_root
+    )
+    completion_paths = dispatch_completion_paths(
+        worker_id, worker_result_path, manifest, project_root
+    )
     digests = item.get("digests")
     digest_values = digests if isinstance(digests, Mapping) else {}
     host_model_value = item.get("hostModelValue")

package/runtime/python/okstra_ctl/doctor.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Iterable
 
 from okstra_project import ResolverError, project_json_path, resolve_project_root
+from okstra_project.resolver import resolve_review_rule_packs
 
 from . import improvement_lenses, worktree_registry
 from .models import provider_wrappers
@@ -99,6 +100,9 @@ def _project_checks(cwd: Path) -> tuple[Path | None, list[DoctorCheck]]:
     architecture = _architecture_declaration_check(project_root)
     if architecture is not None:
         checks.append(architecture)
+    review_packs = _review_rule_pack_check(project_root)
+    if review_packs is not None:
+        checks.append(review_packs)
     return project_root, checks
 
 
@@ -158,6 +162,33 @@ def _architecture_declaration_check(project_root: Path) -> DoctorCheck | None:
     )
 
 
+def _review_rule_pack_check(project_root: Path) -> DoctorCheck | None:
+    """Report a declared review rule pack that no worker will be able to open.
+
+    `reviewRulePacks` is what makes a project's own review standard apply
+    without every brief citing it, so a stale path costs the whole pack in
+    silence: the phase records `project-review-rules: declared <path>
+    unreadable` at best, and a run that reviewed against nothing still passes.
+    Absent declaration stays quiet — brief-cited packs remain the other, equally
+    valid, channel.
+
+    What this cannot check is whether a pack that does resolve was actually read
+    and applied; that stays the worker's own `project-review-rules:` record.
+    """
+    declared = resolve_review_rule_packs(project_root)
+    if not declared:
+        return None
+    missing = [path for path in declared if not Path(path).is_file()]
+    if not missing:
+        return _ok("review rule packs", f"{len(declared)} declared, all readable")
+    return _fail(
+        "review rule packs",
+        f"declared but not readable: {', '.join(missing)} — phases skip a pack "
+        "they cannot open, so the run reviews against fewer rules than declared. "
+        f"Fix the path in {project_json_path(project_root)} or drop the entry.",
+    )
+
+
 def _profile_check(workspace: Path, phase: str) -> DoctorCheck:
     profile = _profile_path(workspace, phase)
     if profile.is_file():