tcw-cli 3.0.0__tar.gz → 3.0.2__tar.gz

{tcw_cli-3.0.0/tcw_cli.egg-info → tcw_cli-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tcw-cli
-Version: 3.0.0
+Version: 3.0.2
 Summary: Taxonomy · Capabilities · Work — a storage-abstracted framework for describing and evolving a software project.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -724,7 +724,8 @@ A change to the product is followed from the first request to the records:
 In filesystem mode, the agent working `qa` may record the verdict itself, unless
 the project's own instructions for `qa` ask for a person to decide. When they
 do, the agent still writes the round, recording the person's decision. In Jira
-mode, a person accepts or rejects on the ticket.
+mode, a person accepts or rejects: on the ticket, or by telling the agent,
+which then moves the ticket and records who decided.
 
 Work reaches taxonomy through those capabilities: a new capability names the
 vocabulary and feature it involves, and those entries must exist first.

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/README.md

@@ -508,7 +508,8 @@ A change to the product is followed from the first request to the records:
 In filesystem mode, the agent working `qa` may record the verdict itself, unless
 the project's own instructions for `qa` ask for a person to decide. When they
 do, the agent still writes the round, recording the person's decision. In Jira
-mode, a person accepts or rejects on the ticket.
+mode, a person accepts or rejects: on the ticket, or by telling the agent,
+which then moves the ticket and records who decided.
 
 Work reaches taxonomy through those capabilities: a new capability names the
 vocabulary and feature it involves, and those entries must exist first.

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tcw-cli"
-version = "3.0.0"
+version = "3.0.2"
 description = "Taxonomy · Capabilities · Work — a storage-abstracted framework for describing and evolving a software project."
 readme = "README.md"
 requires-python = ">=3.11"

tcw_cli-3.0.2/tcw/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.0.2"

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/store/project.py

@@ -39,8 +39,8 @@ def validate_project_id(project_id: str) -> str:
 def override_variable(project_id: str) -> str:
     """The environment variable that says where `project_id` lives on this machine.
 
-    The id, uppercased, with `-` as `_`: `proposit-core` →
-    `TCW_PROJECT_PROPOSIT_CORE`. **Project ids, not repository names** — the two are
+    The id, uppercased, with `-` as `_`: `app-repo` →
+    `TCW_PROJECT_APP_REPO`. **Project ids, not repository names** — the two are
     routinely different, and a workspace where they are crossed is what this
     mapping is most often got wrong against.
 

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/jira/tickets.py

@@ -392,7 +392,9 @@ def delegate_to_jira(project_id: str, title: str, request: str | None,
         raise _named(BackendError(f"created {key} for {project_id}, but did not finish "
                                   f"making it the item {slug}: {error}; finish with "
                                   f"`tcw work tickets adopt {key}` there"), key) from None
-    report(f"the new files in {backend.work_path / slug.folder} are left uncommitted")
+    report(f"the new files in {backend.work_path / slug.folder} are left uncommitted; "
+           f"record them in that project's version control before filing into "
+           f"{project_id} again, or the next ticket stays in its Jira inbox")
     return str(slug)
 
 

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/procedures/unattended-work.md

@@ -29,7 +29,7 @@ advisor alone.
 
 | The stage asks for          | Do this instead |
 | --------------------------- | --------------- |
-| What the requester wants, at request | Do not ask the advisors: what the requester wants is not theirs to know. Write the request from the evidence available, marking each assumption, as the request prompt says when there is no user to ask. Where the backend keeps the request, as Jira does, post your questions with `tcw work comment <slug>` instead and leave its text alone. Then continue. |
+| What the requester wants, at request | Do not ask the advisors: what the requester wants is not theirs to know. Write the request from the evidence available, marking each assumption, as the request prompt says when there is no user to ask. Where the backend keeps the request, as Jira does, post your questions with `tcw work comment <slug>` instead and leave its text alone, and leave the item at request unless the user's own instruction for this run explicitly said to move it out of request. Then move on to other work. |
 | One agent or several        | Decide yourself. One, unless the parts are truly independent. |
 | An open question in a spec or plan | Ask the advisors, then write the answer into the document with the assumption stated in the text. |
 | Review                      | Run the review stage as its prompt says: a read-only reviewer, never the agent that implemented. Apply what you agree with; write down what you reject and why. |

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/prompts/plan.md

@@ -36,8 +36,14 @@ tests cannot check.
 5. Record dependencies between items as blockers, not prose:
    `tcw work edit <slug> --blocked-by <ref>`.
 6. **Too large for one item?** Split it here: `tcw work new "<title>" --parent
-   <slug>` for each part, the part's request on stdin, and plan this item as
-   the parent that ties them together.
+   <slug>` per part, its request on stdin; this item is the parent. A part for
+   another project: `tcw work new "<title>" --project <id>` (no `--parent`). A
+   ticket key printed instead of a slug means no item exists there yet: report
+   it. Otherwise, from inside that project, set `--parent` (a Jira project
+   takes only a ticket on its own site) and `--blocked-by` with `tcw work edit`,
+   then record TCW's uncommitted changes in that project's version control
+   before filing there again: until then a filing is refused, or its Jira
+   ticket stays in the inbox.
 7. **No placeholders.** "TBD", "add error handling", "as in step 3": a step
    nobody can carry out without asking you a question is not a step.
 8. **Self-review.** Re-read the plan against the spec: every acceptance

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/prompts/qa.md

@@ -52,7 +52,7 @@ QA plan scenario as passed, failed or not run, with the evidence for each.
 <!-- /backend -->
 <!-- backend: jira -->
 **Produce** findings, not a verdict. In Jira, qa happens on the ticket, and the
-ticket's status, which people move, is the verdict. You may run the scenarios
+ticket's status, which a person decides, is the verdict. You may run the scenarios
 and post what you found with `tcw work comment <slug>`.
 
 ## Steps
@@ -60,11 +60,15 @@ and post what you found with `tcw work comment <slug>`.
 1. Run each scenario in the QA plan, in the environment it names.
 2. Post one comment listing each scenario as passed, failed or not run, with
    evidence. **No claim without output or an observation from just now.**
-3. Leave the decision to a person. Tell them how to record it: accept by
-   moving the ticket on in Jira, or with
-   `tcw work advance <slug> --to completed --reason "<why>"`; reject with
-   `tcw work advance <slug> --to implement --reason "<what to fix>"`, whose
-   reason becomes the comment implement reads.
+3. A person decides the verdict, never you. Ask them for it. When the person
+   who decides gives you the verdict in this conversation, record it: accepted
+   with `tcw work advance <slug> --to completed --reason "accepted by <name>:
+   <why>"`, rejected with `tcw work advance <slug> --to implement --reason
+   "rejected by <name>: <what to fix>"`, whose reason becomes the comment
+   implement reads. A verdict comes after they have seen your findings: an
+   instruction given before that, such as "accept it if it passes", is not
+   one. They may instead move the ticket in Jira themselves. If they give no
+   verdict, stop at qa and say the item waits for them.
 <!-- /backend -->
 
 ## Exit badly

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/prompts/request.md

@@ -32,10 +32,20 @@ Write it to `tcw work path <slug> request`. Keep any dated `## Added`
 sections already there: they are amendments made after it was written.
 <!-- /backend -->
 <!-- backend: jira -->
-The request is the ticket's description, and Jira owns it: never rewrite it.
-When a section is missing or unclear, post a comment with
+The request is the ticket's description, and Jira owns it: never rewrite it on
+your own judgment. When a section is missing or unclear, post a comment with
 `tcw work comment <slug>` listing what is missing and proposing wording, for
 the requester to adopt.
+
+The requester decides when the request is ready. When they tell you to move
+the item on, in this conversation, do it. If they adopted changed wording,
+first put it into the ticket's description: write it yourself if your harness
+can edit Jira tickets, or ask them to paste it in. Change only what they
+adopted, and keep everything else in the description. Then read it back and
+confirm the description now says what they adopted. Then run
+`tcw work advance <slug> --reason "<who told you to move it>"`. A question,
+such as whether accepting the wording moves the item, is not an instruction to
+move it.
 <!-- /backend -->
 
 ## Steps

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/prompts/spec.md

@@ -51,6 +51,8 @@ it to `tcw work path <slug> spec --handoff`.
 
 - _The code contradicts the request._ Stop and return to request. A spec that
   quietly reinterprets the request is worse than one that refuses.
+- _The requester revises the request._ It stays at spec: record it as an
+  amendment (a dated `## Added`; in Jira, an `Added` comment), and follow it.
 - _The work is too large for one item._ Say so; plan decomposes it.
 - _You cannot ground a claim._ Mark it as an assumption, not a fact.
 - _`tcw work comment` failed._ Report the command and its exit code, do not

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tcw/work/resolve.py

@@ -450,8 +450,14 @@ def stage_footer(row, external, target: str) -> str | None:
     if row.artifact == NO_ARTIFACT:
         return None              # how an arrival becomes work differs by backend
     if row.name in external:
-        text = ("> **When this stage's work is done, a person moves the item on "
-                "in the backend.** Do not move it yourself.")
+        # A person decides; the agent carries out the move once told (TCW-100).
+        move = (f"`tcw work advance {target} --to <stage> --reason \"<who decided, "
+                f"and why>\"`" if row.verdict else
+                f"`tcw work advance {target} --reason \"<who told you>\"`")
+        text = ("> **When this stage's work is done, a person decides whether the "
+                "item moves on.** Move it only when that person tells you to, in "
+                "this conversation; a question or an implied yes is not that. "
+                f"Then run {move}.")
         if row.verdict:
             text += " The verdict is that move."
         return text

{tcw_cli-3.0.0 → tcw_cli-3.0.2/tcw_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tcw-cli
-Version: 3.0.0
+Version: 3.0.2
 Summary: Taxonomy · Capabilities · Work — a storage-abstracted framework for describing and evolving a software project.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -724,7 +724,8 @@ A change to the product is followed from the first request to the records:
 In filesystem mode, the agent working `qa` may record the verdict itself, unless
 the project's own instructions for `qa` ask for a person to decide. When they
 do, the agent still writes the round, recording the person's decision. In Jira
-mode, a person accepts or rejects on the ticket.
+mode, a person accepts or rejects: on the ticket, or by telling the agent,
+which then moves the ticket and records who decided.
 
 Work reaches taxonomy through those capabilities: a new capability names the
 vocabulary and feature it involves, and those entries must exist first.

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tests/test_project_registry.py

@@ -66,13 +66,12 @@ def test_the_override_variable_name_follows_the_id():
     """The id, uppercased with `-` as `_` — node ids, never repository names.
 
     The distinction costs an hour when the two are crossed, which they are in
-    the workspace that prompted this: the directory `proposit-orchestration`
-    holds the node `proposit-app`, and the directory `proposit-app` holds the
-    node `proposit-app-repo`.
+    the workspace that prompted this: the directory `workspace` holds the
+    node `product`, and the directory `app` holds the node `app-repo`.
     """
-    assert override_variable("proposit-core") == "TCW_PROJECT_PROPOSIT_CORE"
-    assert override_variable("proposit-app") == "TCW_PROJECT_PROPOSIT_APP"
-    assert override_variable("proposit-app-repo") == "TCW_PROJECT_PROPOSIT_APP_REPO"
+    assert override_variable("app-repo") == "TCW_PROJECT_APP_REPO"
+    assert override_variable("product") == "TCW_PROJECT_PRODUCT"
+    assert override_variable("app-repo-web") == "TCW_PROJECT_APP_REPO_WEB"
     assert override_variable("a") == "TCW_PROJECT_A"
 
 

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tests/test_prompt_fallback.py

@@ -21,6 +21,11 @@ re-baselining to hide that is what this file exists to prevent.
 **Re-captured again by TCW-76**, for one paragraph only: TCW-74's review fixes
 (`e411e681`) added "Who reviews" to the review prompt after the capture, and
 the recorded bytes were never brought up to it. Nothing else moved.
+
+**Re-captured again by TCW-101**, for two passages it added on purpose: the
+spec prompt's "The requester revises the request" bullet, and the plan
+prompt's step 6 on filing a part into another project. A diff of the old and
+new bytes showed nothing else moved.
 """
 
 import json

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tests/test_repo_lifecycle.py

@@ -47,6 +47,7 @@ DOCUMENTATION = {
     ("docs/changelogs/upcoming/<folder>.md", "Any-Code-Change"),
     ("skills/<component>/SKILL.md", "Skill-Driven-Component"),
     ("skills/configure/references/<document>.md", "Configuration-Key-Change"),
+    ("docs/use-cases.md", "Project-Setup-Change"),
 }
 
 # Programs a `command:` hook runs a script with; the script is then its

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tests/test_shipped_prompts.py

@@ -267,6 +267,26 @@ def test_jira_qa_records_no_verdict():
     assert "tcw work path <slug> qa" not in text and "verdict:" not in text
 
 
+def test_jira_qa_moves_the_ticket_when_the_person_gives_the_verdict():
+    """TCW-100: the person decides; once they give the verdict in the
+    conversation, the agent records it with `advance`, and otherwise stops."""
+    paragraph = _paragraph_with(prompt("qa", "jira"), "gives you the verdict")
+    assert "--to completed --reason" in paragraph
+    assert "--to implement --reason" in paragraph
+    assert "after they have seen your findings" in paragraph
+    assert "stop at qa" in paragraph
+
+
+def test_jira_request_writes_adopted_wording_before_moving():
+    """TCW-100: adopted wording goes into the description, is read back, and
+    only then is the item moved, with a reason naming who said to move it."""
+    paragraph = _paragraph_with(prompt("request", "jira"), "tell you to move")
+    for words in ("description", "paste", "read it back",
+                  "tcw work advance <slug> --reason"):
+        assert words in paragraph, words
+    assert paragraph.index("read it back") < paragraph.index("tcw work advance")
+
+
 @pytest.mark.parametrize("sid", sorted(SHIPPED))
 def test_no_prompt_tells_the_agent_to_ask_what_it_is_reading(sid):
     """`tcw work lifecycle --stage <id>` inside the text that command reports
@@ -291,3 +311,30 @@ def test_the_self_review_pass_appears_in_exactly_three_prompts():
     prompts = load_builtins().stage_prompts
     found = {sid for sid, text in prompts.items() if "self-review" in text.lower()}
     assert found == {"spec", "plan", "implement"}
+
+
+def test_jira_request_keeps_what_the_requester_did_not_change():
+    """TCW-101: adopted wording changes only what was adopted."""
+    paragraph = _paragraph_with(prompt("request", "jira"), "tell you to move")
+    assert "keep everything else in the description" in paragraph
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+def test_spec_says_what_to_do_when_the_requester_revises_the_request(backend):
+    """TCW-101: the item stays at spec, and the change is recorded where the
+    request lives, in either backend's form."""
+    paragraph = _paragraph_with(prompt("spec", backend), "The requester revises")
+    for words in ("stays at spec", "amendment", "## Added", "`Added` comment"):
+        assert words in paragraph, words
+
+
+def test_plan_says_how_to_file_a_part_into_another_project():
+    """TCW-101: --project takes no --parent; the parent is set from inside
+    that project, and only then is everything recorded in its version
+    control, because the edit itself writes a file there; a ticket key in
+    place of a slug means there is no item to edit."""
+    paragraph = _paragraph_with(prompt("plan", "filesystem"), "Too large for one item")
+    order = [paragraph.index(w) for w in ("--project", "tcw work edit",
+                                          "version control")]
+    assert order == sorted(order), paragraph
+    assert "ticket key printed instead of a slug" in paragraph

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tests/test_store_provisioning.py

@@ -320,25 +320,25 @@ def test_the_cache_key_is_unchanged():
     exactly what a shared normalizer would change.
     """
     expected = {
-        ("https://github.com/Proposit-App/proposit-orchestration.git", "main"):
-            "github.com-proposit-app-proposit-orchestration-73cbcd814e44",
-        ("https://github.com/Proposit-App/proposit-orchestration", "main"):
-            "github.com-proposit-app-proposit-orchestration-bc251d728153",
-        ("git@github.com:Proposit-App/proposit-orchestration.git", "main"):
-            "github.com-proposit-app-proposit-orchestration-d5bbabd1bdc8",
-        ("https://github.com/Proposit-App/proposit-orchestration.git", "dev"):
-            "github.com-proposit-app-proposit-orchestration-447264907fc6",
+        ("https://github.com/Example-Org/workspace.git", "main"):
+            "github.com-example-org-workspace-ec7917e6e4c3",
+        ("https://github.com/Example-Org/workspace", "main"):
+            "github.com-example-org-workspace-f86dcb6399fe",
+        ("git@github.com:Example-Org/workspace.git", "main"):
+            "github.com-example-org-workspace-1a37f0559bb2",
+        ("https://github.com/Example-Org/workspace.git", "dev"):
+            "github.com-example-org-workspace-c6c86f756591",
     }
     for (url, ref), key in expected.items():
         assert checkouts._cache_key(RepositoryDeclaration(url=url, ref=ref)) == key
 
 
 @pytest.mark.parametrize("spelling", [
-    "https://github.com/Proposit-App/proposit-orchestration",
-    "https://github.com/Proposit-App/proposit-orchestration.git",
-    "https://github.com/Proposit-App/proposit-orchestration/",
-    "  https://github.com/Proposit-App/proposit-orchestration.git  ",
-    "git@github.com:Proposit-App/proposit-orchestration.git",
+    "https://github.com/Example-Org/workspace",
+    "https://github.com/Example-Org/workspace.git",
+    "https://github.com/Example-Org/workspace/",
+    "  https://github.com/Example-Org/workspace.git  ",
+    "git@github.com:Example-Org/workspace.git",
 ])
 def test_two_spellings_of_one_repository_normalize_alike(spelling):
     """The question `_cache_key` deliberately answers the other way.
@@ -348,18 +348,18 @@ def test_two_spellings_of_one_repository_normalize_alike(spelling):
     new resolution rung has to see through that.
     """
     canonical = checkouts.normalized_url(
-        "https://github.com/Proposit-App/proposit-orchestration")
+        "https://github.com/Example-Org/workspace")
     assert checkouts.normalized_url(spelling) == canonical
 
 
 @pytest.mark.parametrize("other", [
-    "https://github.com/Proposit-App/proposit-core",
-    "https://github.com/Someone-Else/proposit-orchestration",
-    "https://gitlab.invalid/Proposit-App/proposit-orchestration",
+    "https://github.com/Example-Org/core",
+    "https://github.com/Someone-Else/workspace",
+    "https://gitlab.invalid/Example-Org/workspace",
 ])
 def test_two_different_repositories_do_not_normalize_alike(other):
     assert checkouts.normalized_url(other) != checkouts.normalized_url(
-        "https://github.com/Proposit-App/proposit-orchestration")
+        "https://github.com/Example-Org/workspace")
 
 
 def test_an_undeclared_component_is_a_no_op(tmp_path):

{tcw_cli-3.0.0 → tcw_cli-3.0.2}/tests/test_upstream_projects.py

@@ -90,7 +90,7 @@ def test_the_upstream_does_not_see_its_reader(tmp_path):
 
 
 def test_an_upstream_reached_through_a_parent_is_found(tmp_path):
-    """The proposit-app shape: a package reaches core through its parent."""
+    """The app-repository shape: a package reaches core through its parent."""
     config(tmp_path / "repo", "id: repo\nprojects:\n  children:\n"
                                "    pkg: pkg\n  upstream:\n    core: ../core\n")
     config(tmp_path / "repo" / "pkg", "id: pkg\nprojects:\n  parent:\n"
@@ -545,7 +545,7 @@ def test_an_incomplete_tracker_with_a_parent_does_not(tmp_path):
     assert "required" in text and _NO_PARENT not in text, text
 
 
-# ── the Proposit shape, end to end ───────────────────────────────────────────
+# ── the workspace shape, end to end ──────────────────────────────────────────
 
 _ROOT_TRACKER = {
     "provider": "jira-cloud",
@@ -561,33 +561,33 @@ def _edit(node: Path, change) -> None:
     (node / "tcw-config.yaml").write_text(yaml.safe_dump(cfg, sort_keys=False))
 
 
-def _proposit(tmp_path: Path) -> dict[str, Path]:
-    """The shape the request came from: an orchestration root `proposit-app` with
-    children `proposit-core` and `proposit-app-repo`; a package `shared` below the
+def _workspace(tmp_path: Path) -> dict[str, Path]:
+    """The shape the request came from: an orchestration root `product` with
+    children `core` and `app-repo`; a package `shared` below the
     app repository extending core's taxonomy; core's tracker block holding only
     `candidate-query` and inheriting the rest from the root."""
     root = tmp_path / "ws"
-    nodes = {"root": root, "core": root / "proposit-core",
-             "app": root / "proposit-app",
-             "shared": root / "proposit-app" / "packages" / "shared"}
-    for key, pid in (("root", "proposit-app"), ("core", "proposit-core"),
-                     ("app", "proposit-app-repo"), ("shared", "shared")):
+    nodes = {"root": root, "core": root / "core",
+             "app": root / "app",
+             "shared": root / "app" / "packages" / "shared"}
+    for key, pid in (("root", "product"), ("core", "core"),
+                     ("app", "app-repo"), ("shared", "shared")):
         nodes[key].mkdir(parents=True)
         if key != "shared":            # three repositories, as in the workspace
             _git(nodes[key], "init", "-q", "-b", "main")
         init(["taxonomy", "capabilities", "work"], nodes[key], pid)
     _edit(root, lambda c: c.update({"projects": {"children": {
-        "proposit-core": "proposit-core", "proposit-app-repo": "proposit-app"}}}))
+        "core": "core", "app-repo": "app"}}}))
     _set_tracker(root, dict(_ROOT_TRACKER))
     _edit(nodes["core"], lambda c: c.update({"projects": {
-        "parent": {"proposit-app": ".."}}}))
+        "parent": {"product": ".."}}}))
     _set_tracker(nodes["core"], {"candidate-query": "project = CORE"})
     _edit(nodes["app"], lambda c: c.update({"projects": {
-        "parent": {"proposit-app": ".."}, "children": {"shared": "packages/shared"}}}))
+        "parent": {"product": ".."}, "children": {"shared": "packages/shared"}}}))
     _edit(nodes["shared"], lambda c: c.update({"projects": {
-        "parent": {"proposit-app-repo": "../.."}}}))
+        "parent": {"app-repo": "../.."}}}))
     assert _tcw(nodes["core"], "taxonomy", "add", "Argument").returncode == 0
-    out = _tcw(nodes["shared"], "taxonomy", "extends", "add", "proposit-core")
+    out = _tcw(nodes["shared"], "taxonomy", "extends", "add", "core")
     assert out.returncode == 0, out.stderr
     return nodes
 
@@ -605,16 +605,16 @@ def _assert_state(nodes, *, warned: set[str]) -> None:
         assert code == 0, (key, text)
         has_warning = "read as an upstream project" in text
         assert has_warning == (key in warned), (key, text)
-    out = _tcw(nodes["shared"], "taxonomy", "show", "proposit-core/argument")
+    out = _tcw(nodes["shared"], "taxonomy", "show", "core/argument")
     assert out.returncode == 0, out.stderr
 
 
-def test_the_proposit_migration_passes_through_no_blocked_state(tmp_path):
-    nodes = _proposit(tmp_path)
+def test_the_workspace_migration_passes_through_no_blocked_state(tmp_path):
+    nodes = _workspace(tmp_path)
     _assert_state(nodes, warned=set())
 
     step_2 = lambda c: c["projects"].update(  # noqa: E731
-        {"upstream": {"proposit-core": "../proposit-core"}})
+        {"upstream": {"core": "../core"}})
 
     # The forbidden middle state: step 2 before step 1.
     _edit(nodes["app"], step_2)
@@ -624,8 +624,8 @@ def test_the_proposit_migration_passes_through_no_blocked_state(tmp_path):
 
     # Step 1: the root moves core from children to upstream, one edit.
     def step_1(c):
-        c["projects"]["children"].pop("proposit-core")
-        c["projects"]["upstream"] = {"proposit-core": "proposit-core"}
+        c["projects"]["children"].pop("core")
+        c["projects"]["upstream"] = {"core": "core"}
     _edit(nodes["root"], step_1)
     _assert_state(nodes, warned={"root", "core", "app", "shared"})
 
@@ -642,7 +642,7 @@ def test_the_proposit_migration_passes_through_no_blocked_state(tmp_path):
     _edit(nodes["core"], lambda c: c["work"].pop("tracker"))
     _assert_state(nodes, warned=set())
     out = _tcw(nodes["core"], "validate")
-    assert "proposit-app" not in out.stdout + out.stderr, out.stdout
+    assert "product" not in out.stdout + out.stderr, out.stdout
 
 
 # ── the CLI's view of an absent upstream, and of what lies beyond one ────────

tcw_cli-3.0.0/tcw/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.0.0"