peaches 0.1.0__tar.gz

peaches-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ella Inng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

peaches-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: peaches
+Version: 0.1.0
+Summary: A selected text workflow workbench over independent Python composition libraries.
+Author: ellainng
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: wispsy>=0.0.1
+Requires-Dist: scriptty>=0.1.0
+Requires-Dist: scriptty[cli]>=0.1.0 ; extra == 'cli'
+Requires-Dist: scriptty[sequence]>=0.1.0 ; python_full_version >= '3.14' and extra == 'sequence'
+Requires-Dist: wispsy[table]>=0.0.1 ; python_full_version >= '3.14' and extra == 'table'
+Requires-Dist: scriptty[terminal]>=0.1.0 ; python_full_version >= '3.14' and extra == 'terminal'
+Requires-Python: >=3.11
+Project-URL: Source, https://github.com/wispsy/peaches
+Project-URL: Issues, https://github.com/wispsy/peaches/issues
+Project-URL: Project, https://github.com/orgs/wispsy/projects/23
+Provides-Extra: cli
+Provides-Extra: sequence
+Provides-Extra: table
+Provides-Extra: terminal
+Description-Content-Type: text/markdown
+
+# Peaches
+
+A text workflow workbench: inspect, normalize and report text, then optionally
+review progress in a terminal or consume typed tables and Markdown.
+
+```python
+import asyncio
+from peaches import TextWorkbench
+
+workbench = TextWorkbench()
+outcome = asyncio.run(workbench.report(" Hello   WORLD "))
+assert outcome["outputs"]["report"] == {"text": "hello world", "words": 2, "characters": 11}
+document = workbench.inspect()
+```
+
+The library and optional CLI support Python 3.11+. Lifecycle, table and terminal
+profiles require Python 3.14+. Install selected source profiles from this checkout:
+
+```sh
+uv run --python 3.11 --extra cli peaches report ' Hello WORLD '
+uv run --python 3.11 --extra cli peaches inspect
+uv run --python 3.14 --extra cli --extra sequence peaches report ' Hello WORLD ' --checkpoint progress.json --pace function
+uv run --python 3.14 --extra cli --extra sequence peaches report ' Hello WORLD ' --checkpoint progress.json --resume
+uv run --python 3.14 --extra cli --extra table peaches markdown --text ' Hello WORLD ' --text ' More WORDS '
+uv run --python 3.14 --extra terminal peaches review ' Hello WORLD ' --checkpoint review.json
+```
+
+Run requires a new checkpoint path; --resume requires existing progress. --retry
+explicitly repeats an uncertain step; --restart repeats the workflow. Outcomes
+use Scriptty's schema-1 JSON contract. Commands keep UTF-8 results on stdout and
+diagnostics/errors on stderr independently of console encoding.
+
+`workbench.table(texts)` returns the existing typed Headless Spreadsheets Table;
+`markdown(texts)` selects its detached, escaped renderer. `terminal_model` supplies
+the same Scriptty/Carets model for embedding/testing; `await review(...)` selects
+native terminal ownership. The native host requires a supported POSIX TTY. Every
+surface uses the same curated text functions, explicit mappings and selected
+capabilities. Terminal review requires capability confirmation before execution.
+
+Peaches composes Wispsy's typed reference, Hidden Moves catalogs, moveset pipelines
+and Scriptty's passive documents/application API. Func_seq owns optional durable
+execution; Carets owns optional terminal behavior; Headless Spreadsheets owns
+typed tables and rendering. The workbench introduces no second parser/executor
+or new grammar. Inspect returns the existing passive schema-1 document.
+
+This is a functional source-development package at 0.0.1.dev0 with immutable
+sibling revisions. It is independently versioned and requires no hosted service.
+Release/license/dependency publication choices remain in the
+[Wispsy Composition Project](https://github.com/orgs/wispsy/projects/23).
+Build with `uv build --out-dir dist`; `python scripts/qualify.py dist` installs
+wheel/source artifacts outside the checkout, checks optional-profile isolation,
+actual commands/restart, synthetic terminal/table equivalence and native POSIX
+keyboard selection/run/quit with terminal restoration. CI qualifies Python 3.11
+on Linux/Windows and Python 3.14 on Linux/macOS/Windows.

peaches-0.1.0/README.md

@@ -0,0 +1,54 @@
+# Peaches
+
+A text workflow workbench: inspect, normalize and report text, then optionally
+review progress in a terminal or consume typed tables and Markdown.
+
+```python
+import asyncio
+from peaches import TextWorkbench
+
+workbench = TextWorkbench()
+outcome = asyncio.run(workbench.report(" Hello   WORLD "))
+assert outcome["outputs"]["report"] == {"text": "hello world", "words": 2, "characters": 11}
+document = workbench.inspect()
+```
+
+The library and optional CLI support Python 3.11+. Lifecycle, table and terminal
+profiles require Python 3.14+. Install selected source profiles from this checkout:
+
+```sh
+uv run --python 3.11 --extra cli peaches report ' Hello WORLD '
+uv run --python 3.11 --extra cli peaches inspect
+uv run --python 3.14 --extra cli --extra sequence peaches report ' Hello WORLD ' --checkpoint progress.json --pace function
+uv run --python 3.14 --extra cli --extra sequence peaches report ' Hello WORLD ' --checkpoint progress.json --resume
+uv run --python 3.14 --extra cli --extra table peaches markdown --text ' Hello WORLD ' --text ' More WORDS '
+uv run --python 3.14 --extra terminal peaches review ' Hello WORLD ' --checkpoint review.json
+```
+
+Run requires a new checkpoint path; --resume requires existing progress. --retry
+explicitly repeats an uncertain step; --restart repeats the workflow. Outcomes
+use Scriptty's schema-1 JSON contract. Commands keep UTF-8 results on stdout and
+diagnostics/errors on stderr independently of console encoding.
+
+`workbench.table(texts)` returns the existing typed Headless Spreadsheets Table;
+`markdown(texts)` selects its detached, escaped renderer. `terminal_model` supplies
+the same Scriptty/Carets model for embedding/testing; `await review(...)` selects
+native terminal ownership. The native host requires a supported POSIX TTY. Every
+surface uses the same curated text functions, explicit mappings and selected
+capabilities. Terminal review requires capability confirmation before execution.
+
+Peaches composes Wispsy's typed reference, Hidden Moves catalogs, moveset pipelines
+and Scriptty's passive documents/application API. Func_seq owns optional durable
+execution; Carets owns optional terminal behavior; Headless Spreadsheets owns
+typed tables and rendering. The workbench introduces no second parser/executor
+or new grammar. Inspect returns the existing passive schema-1 document.
+
+This is a functional source-development package at 0.0.1.dev0 with immutable
+sibling revisions. It is independently versioned and requires no hosted service.
+Release/license/dependency publication choices remain in the
+[Wispsy Composition Project](https://github.com/orgs/wispsy/projects/23).
+Build with `uv build --out-dir dist`; `python scripts/qualify.py dist` installs
+wheel/source artifacts outside the checkout, checks optional-profile isolation,
+actual commands/restart, synthetic terminal/table equivalence and native POSIX
+keyboard selection/run/quit with terminal restoration. CI qualifies Python 3.11
+on Linux/Windows and Python 3.14 on Linux/macOS/Windows.

peaches-0.1.0/cli_tests/test_cli.py

@@ -0,0 +1,27 @@
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from wispsy.reference import run_reference
+
+
+class InstalledCommandTests(unittest.TestCase):
+    def test_module_and_console_entrypoints_match_library_outcomes(self):
+        text = " HéLLo   🌍 "
+        console = Path(sys.executable).with_name("peaches.exe" if sys.platform == "win32" else "peaches")
+        with tempfile.TemporaryDirectory() as outside:
+            for prefix in ([sys.executable, "-I", "-m", "peaches"], [str(console)]):
+                result = subprocess.run([*prefix, "report", text], cwd=outside, env={**os.environ, "PYTHONIOENCODING": "cp1252"}, capture_output=True)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertEqual(json.loads(result.stdout)["outputs"], {"report": run_reference(text)})
+            inspected = subprocess.run([str(console), "inspect"], cwd=outside, capture_output=True)
+            self.assertEqual(inspected.returncode, 0, inspected.stderr)
+            self.assertEqual(json.loads(inspected.stdout)["status"], "inspected")
+            failure = subprocess.run([str(console), "report"], cwd=outside, capture_output=True)
+            self.assertEqual(failure.returncode, 2)
+            self.assertEqual(failure.stdout, b"")
+            self.assertEqual(json.loads(failure.stderr.splitlines()[-1])["schema"], 1)

peaches-0.1.0/profile_tests/test_native_review.py

@@ -0,0 +1,57 @@
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+
+@unittest.skipUnless(os.name == "posix", "Native POSIX review host")
+class NativeReviewTests(unittest.TestCase):
+    def test_actual_terminal_selection_run_and_quit_restore_the_session(self):
+        import fcntl
+        import pty
+        import select
+        import struct
+        import termios
+
+        master, slave = pty.openpty()
+        fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 24, 80, 0, 0))
+        original = termios.tcgetattr(slave)
+        with tempfile.TemporaryDirectory() as directory:
+            checkpoint = Path(directory) / "review.json"
+            process = subprocess.Popen([sys.executable, "-I", "-m", "peaches", "review", " Hello WORLD ",
+                "--checkpoint", str(checkpoint)], stdin=slave, stderr=slave, stdout=subprocess.PIPE, cwd=directory)
+            def drain():
+                if select.select([master], [], [], 0.02)[0]:
+                    os.read(master, 65536)
+            try:
+                deadline = time.monotonic() + 5
+                while termios.tcgetattr(slave)[3] & termios.ICANON and process.poll() is None and time.monotonic() < deadline:
+                    drain()
+                self.assertFalse(termios.tcgetattr(slave)[3] & termios.ICANON, "Native raw session did not start")
+                # Input editor → explicitly select both capabilities → actions → run.
+                os.write(master, b"\t \x1b[B \t\r")
+                completed = False
+                deadline = time.monotonic() + 5
+                while process.poll() is None and time.monotonic() < deadline:
+                    drain()
+                    if checkpoint.exists() and json.loads(checkpoint.read_text())["status"] == "completed":
+                        completed = True
+                        break
+                self.assertTrue(completed, "Native keyboard execution did not complete")
+                os.write(master, b"q")
+                output, _ = process.communicate(timeout=5)
+                self.assertEqual(process.returncode, 0, output)
+                self.assertEqual(json.loads(output)["outputs"], {"report": {"text": "hello world", "words": 2, "characters": 11}})
+                restored = termios.tcgetattr(slave)
+                mask = termios.ICANON | termios.ECHO
+                self.assertEqual(restored[3] & mask, original[3] & mask)
+            finally:
+                if process.poll() is None:
+                    process.kill()
+                    process.communicate()
+                os.close(master)
+                os.close(slave)

peaches-0.1.0/profile_tests/test_profiles.py

@@ -0,0 +1,40 @@
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from carets import KeyMsg
+from carets.testing import TestProgram
+from peaches import TextWorkbench
+from wispsy.reference import run_reference
+
+
+class ProfileTests(unittest.IsolatedAsyncioTestCase):
+    async def test_typed_table_markdown_and_terminal_reuse_report_contract(self):
+        workbench, text = TextWorkbench(), " Hello   WORLD "
+        self.assertEqual(workbench.table([text]).to_records(), [run_reference(text)])
+        self.assertIn("&lt;script&gt;", workbench.markdown(["<script>"]))
+        with tempfile.TemporaryDirectory() as directory:
+            model = workbench.terminal_model(text, checkpoint=str(Path(directory) / "terminal.json"))
+            test = TestProgram(model)
+            model.attach(test.program)
+            async with test:
+                await test.send(KeyMsg("tab"), KeyMsg(" "), KeyMsg("down"), KeyMsg(" "), KeyMsg("tab"), KeyMsg("enter"))
+                await test.wait_for(lambda: model.status == "completed")
+                self.assertEqual(model.outcome["outputs"], {"report": run_reference(text)})
+
+    async def test_installed_commands_pause_and_resume_in_separate_processes(self):
+        with tempfile.TemporaryDirectory() as directory:
+            checkpoint = str(Path(directory) / "progress.json")
+            def command(*options):
+                result = subprocess.run([sys.executable, "-I", "-m", "peaches", "report", " Hello WORLD ", "--checkpoint", checkpoint, *options], cwd=directory, capture_output=True)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                return json.loads(result.stdout)
+            first = command("--pace", "function")
+            self.assertEqual((first["status"], first["completed"]), ("paused", ["normalize"]))
+            resumed = command("--resume")
+            self.assertEqual(resumed["status"], "completed")
+            self.assertEqual(resumed["run_id"], first["run_id"])
+            self.assertEqual(resumed["outputs"], {"report": run_reference(" Hello WORLD ")})

peaches-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "peaches"
+version = "0.1.0"
+license = "MIT"
+license-files = ["LICENSE"]
+description = "A selected text workflow workbench over independent Python composition libraries."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "wispsy>=0.0.1",
+    "scriptty>=0.1.0",
+]
+
+[[project.authors]]
+name = "ellainng"
+
+[project.optional-dependencies]
+cli = ["scriptty[cli]>=0.1.0"]
+sequence = ["scriptty[sequence]>=0.1.0 ; python_version >= '3.14'"]
+terminal = ["scriptty[terminal]>=0.1.0 ; python_version >= '3.14'"]
+table = ["wispsy[table]>=0.0.1 ; python_version >= '3.14'"]
+
+[project.scripts]
+peaches = "peaches.cli:main"
+
+[project.urls]
+Source = "https://github.com/wispsy/peaches"
+Issues = "https://github.com/wispsy/peaches/issues"
+Project = "https://github.com/orgs/wispsy/projects/23"
+
+[build-system]
+requires = ["uv_build>=0.12.19,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-include = [
+    "LICENSE",
+    "tests/*.py",
+    "cli_tests/*.py",
+    "profile_tests/*.py",
+    "scripts/*.py",
+    "docs/*.md",
+]

peaches-0.1.0/pyproject.toml.orig

@@ -0,0 +1,34 @@
+[project]
+name = "peaches"
+version = "0.1.0"
+license = "MIT"
+license-files = ["LICENSE"]
+description = "A selected text workflow workbench over independent Python composition libraries."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "ellainng" }]
+dependencies = [
+    "wispsy>=0.0.1",
+    "scriptty>=0.1.0",
+]
+
+[project.optional-dependencies]
+cli = ["scriptty[cli]>=0.1.0"]
+sequence = ["scriptty[sequence]>=0.1.0 ; python_version >= '3.14'"]
+terminal = ["scriptty[terminal]>=0.1.0 ; python_version >= '3.14'"]
+table = ["wispsy[table]>=0.0.1 ; python_version >= '3.14'"]
+
+[project.scripts]
+peaches = "peaches.cli:main"
+
+[project.urls]
+Source = "https://github.com/wispsy/peaches"
+Issues = "https://github.com/wispsy/peaches/issues"
+Project = "https://github.com/orgs/wispsy/projects/23"
+
+[build-system]
+requires = ["uv_build>=0.12.19,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-include = ["LICENSE", "tests/*.py", "cli_tests/*.py", "profile_tests/*.py", "scripts/*.py", "docs/*.md"]

peaches-0.1.0/scripts/qualify.py

@@ -0,0 +1,46 @@
+"""Install both workbench artifacts outside source and select optional profiles."""
+
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import zipfile
+from email.parser import BytesParser
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    directory = Path(sys.argv[1]).resolve()
+    artifacts = sorted([*directory.glob("*.whl"), *directory.glob("*.tar.gz")])
+    assert len(artifacts) == 2
+    wheel, = directory.glob("*.whl")
+    with zipfile.ZipFile(wheel) as archive:
+        assert "peaches/py.typed" in archive.namelist()
+        metadata, = [name for name in archive.namelist() if name.endswith("/METADATA")]
+        message = BytesParser().parsebytes(archive.read(metadata))
+        assert message["Name"] == "peaches" and message["Requires-Python"] == ">=3.11"
+    for artifact in artifacts:
+        with tempfile.TemporaryDirectory() as temporary:
+            outside = Path(temporary)
+            environment = outside / "env"
+            subprocess.run(["uv", "venv", str(environment), "--python", sys.executable], check=True)
+            python = environment / ("Scripts/python.exe" if sys.platform == "win32" else "bin/python")
+            def run(*command):
+                subprocess.run(command, check=True, cwd=outside)
+            run("uv", "pip", "install", "--python", str(python), str(artifact))
+            run(str(python), "-I", "-c", "import importlib.util, peaches; assert all(importlib.util.find_spec(name) is None for name in ('func_seq','carets','headless_spreadsheets','expose_interface'))")
+            run(str(python), "-I", "-m", "unittest", "discover", "-s", str(ROOT / "tests"), "-v")
+            run("uv", "pip", "install", "--python", str(python), f"{artifact}[cli]")
+            run(str(python), "-I", "-m", "unittest", "discover", "-s", str(ROOT / "cli_tests"), "-v")
+            if sys.version_info >= (3, 14):
+                run("uv", "pip", "install", "--python", str(python), f"{artifact}[cli,sequence,table,terminal]")
+                run(str(python), "-I", "-m", "unittest", "discover", "-s", str(ROOT / "profile_tests"), "-v")
+            run("uv", "pip", "check", "--python", str(python))
+        print(json.dumps({"schema": 1, "artifact": artifact.name, "sha256": hashlib.sha256(artifact.read_bytes()).hexdigest()}))
+
+
+if __name__ == "__main__":
+    main()

peaches-0.1.0/src/peaches/__init__.py

@@ -0,0 +1,5 @@
+"""A curated text workbench with independently optional presentation/lifecycle."""
+
+from .workbench import TextWorkbench
+
+__all__ = ["TextWorkbench"]

peaches-0.1.0/src/peaches/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

peaches-0.1.0/src/peaches/cli.py

@@ -0,0 +1,51 @@
+"""Expose the curated workbench as ordinary application commands."""
+
+import contextlib
+import sys
+
+from expose_interface import Interface, UsageError, option
+from moveset.core import canonical
+
+from .workbench import TextWorkbench
+
+
+def build_interface():
+    app = Interface("peaches", description="Inspect and run the selected text workbench.")
+
+    @app.command(name="inspect")
+    def inspect_workflow():
+        return {"schema": 1, "status": "inspected", "workflow": TextWorkbench().inspect()}
+
+    @app.command(name="report")
+    async def report(text: str, *, checkpoint: str | None = None, resume: bool = False,
+                     retry: bool = False, restart: bool = False, pace: str = "auto"):
+        """Normalize/report text; optional checkpoints retain explicit recovery."""
+        return await TextWorkbench().report(text, checkpoint=checkpoint, resume=resume,
+                                            retry=retry, restart=restart, pace=pace)
+
+    @app.command(name="markdown")
+    @option("--text", dest="texts", multiple=True, required=True)
+    def markdown(*, texts: list[str]):
+        """Render typed reports through the optional table profile."""
+        return {"schema": 1, "status": "rendered", "format": "markdown", "text": TextWorkbench().markdown(texts)}
+
+    @app.command(name="review")
+    async def review(text: str, *, checkpoint: str):
+        """Select the optional interactive POSIX terminal profile."""
+        return await TextWorkbench().review(text, checkpoint=checkpoint)
+
+    return app
+
+
+def main(argv=None):
+    try:
+        with contextlib.redirect_stdout(sys.stderr):
+            outcome = build_interface().invoke(argv)
+        if outcome is not None:
+            sys.stdout.buffer.write(canonical(outcome) + b"\n")
+            sys.stdout.buffer.flush()
+    except Exception as error:
+        record = {"schema": 1, "status": "error", "error": type(error).__name__, "message": str(error)}
+        sys.stderr.buffer.write(b"\n" + canonical(record) + b"\n")
+        sys.stderr.buffer.flush()
+        raise SystemExit(2 if isinstance(error, UsageError) else 1) from None

peaches-0.1.0/src/peaches/workbench.py

@@ -0,0 +1,60 @@
+"""Application choices over the qualified reference and scripting API."""
+
+import json
+import sys
+
+from scriptty import loads
+from scriptty.application import execute
+from wispsy.composition import text_workflow_document
+
+
+class TextWorkbench:
+    """Inspect/report text without requiring a terminal, storage or HTTP service."""
+
+    def __init__(self, *, catalog_version="wispsy-text-v1"):
+        self.catalog_version = catalog_version
+        self.workflow = loads(json.dumps(text_workflow_document()), source="peaches:text-report")
+
+    def inspect(self):
+        return self.workflow.inspect()
+
+    def catalog(self):
+        """Explicitly assemble only the curated reference capabilities on demand."""
+        from wispsy.integration import build_catalog
+
+        return build_catalog()
+
+    async def report(self, text: str, *, checkpoint=None, resume=False, retry=False,
+                     restart=False, pace="auto", control=None, observer=None):
+        """Return the same schema-1 outcome used by scripting/terminal hosts."""
+        return await execute(self.workflow, self.catalog(), catalog_version=self.catalog_version,
+            inputs={"text": text}, checkpoint=checkpoint, resume=resume, retry=retry,
+            restart=restart, pace=pace, control=control, observer=observer)
+
+    def table(self, texts: list[str]):
+        if sys.version_info < (3, 14):
+            raise ImportError("Install peaches[table] on Python 3.14+")
+        try:
+            from wispsy.tabular import normalize_table
+        except ImportError:
+            raise ImportError("Install peaches[table] on Python 3.14+") from None
+        return normalize_table(texts)
+
+    def markdown(self, texts: list[str]) -> str:
+        return self.table(texts).to_document().to_markdown()
+
+    def terminal_model(self, text: str, *, checkpoint):
+        try:
+            from scriptty.terminal import WorkflowTerminal
+        except ImportError:
+            raise ImportError("Install peaches[terminal] on Python 3.14+") from None
+        return WorkflowTerminal(self.workflow, self.catalog(), catalog_version=self.catalog_version,
+                                checkpoint=checkpoint, inputs={"text": text})
+
+    async def review(self, text: str, *, checkpoint, **terminal_options):
+        try:
+            from scriptty.terminal import run_terminal
+        except ImportError:
+            raise ImportError("Install peaches[terminal] on Python 3.14+") from None
+        return await run_terminal(self.workflow, self.catalog(), catalog_version=self.catalog_version,
+                                  checkpoint=checkpoint, inputs={"text": text}, **terminal_options)

peaches-0.1.0/tests/test_workbench.py

@@ -0,0 +1,22 @@
+import unittest
+
+from peaches import TextWorkbench
+from wispsy.reference import run_reference
+
+
+class WorkbenchTests(unittest.IsolatedAsyncioTestCase):
+    async def test_report_reuses_the_same_typed_reference_without_lifecycle(self):
+        workbench = TextWorkbench()
+        for text in (" Hello  WORLD ", " Straße 🌍 ", ""):
+            outcome = await workbench.report(text)
+            self.assertEqual((outcome["schema"], outcome["status"], outcome["outputs"]),
+                             (1, "completed", {"report": run_reference(text)}))
+            self.assertIsNone(outcome["run_id"])
+        with self.assertRaises(ValueError):
+            await workbench.report(2)
+
+    async def test_inspection_is_passive_and_returns_detached_metadata(self):
+        workbench = TextWorkbench()
+        workbench.inspect()["steps"].clear()
+        self.assertEqual(len(workbench.inspect()["steps"]), 2)
+        self.assertEqual([step["capability"] for step in workbench.inspect()["steps"]], ["text.normalize", "text.report"])