hypershell 2.8.0__tar.gz → 2.8.2__tar.gz

{hypershell-2.8.0 → hypershell-2.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypershell
-Version: 2.8.0
+Version: 2.8.2
 Summary: A cross-platform, high-throughput computing utility for processing shell commands over a distributed, asynchronous queue.
 Project-URL: Homepage, https://hypershell.org
 Project-URL: Documentation, https://hypershell.readthedocs.io
@@ -54,7 +54,7 @@ HyperShell v2: Distributed Task Execution for HPC
     :target: https://github.com/hypershell/hypershell/releases
     :alt: Github Release
 
-.. image:: https://img.shields.io/badge/Python-3.9+-blue.svg
+.. image:: https://img.shields.io/badge/Python-3.11+-blue.svg
     :target: https://www.python.org/downloads
     :alt: Python Versions
 

{hypershell-2.8.0 → hypershell-2.8.2}/README.rst

@@ -9,7 +9,7 @@ HyperShell v2: Distributed Task Execution for HPC
     :target: https://github.com/hypershell/hypershell/releases
     :alt: Github Release
 
-.. image:: https://img.shields.io/badge/Python-3.9+-blue.svg
+.. image:: https://img.shields.io/badge/Python-3.11+-blue.svg
     :target: https://www.python.org/downloads
     :alt: Python Versions
 

{hypershell-2.8.0 → hypershell-2.8.2}/docs/_include/task_update_desc.rst

@@ -4,7 +4,9 @@ Include any number of `FIELD=VALUE` or tag `KEY:VALUE` positional arguments.
 
 The ``-w``/``--where`` and ``-t``/``--with-tag`` operate just as in the search command.
 
-Using ``--cancel`` sets `schedule_time` to now and `exit_status` to -1.
+Using ``--cancel`` marks tasks as cancelled: `schedule_time` and `completion_time`
+are set to now and `exit_status` to -1. A cancelled task is terminal - it will not be
+scheduled, retried, or reverted on ``--restart``.
 
 Using ``--revert`` reverts everything as if the task was new again.
 

{hypershell-2.8.0 → hypershell-2.8.2}/docs/_include/task_update_help.rst

@@ -10,8 +10,9 @@ Options
 ``--cancel``
     Cancel specified tasks.
 
-    Cancelling a task means it will no longer be scheduled.
-    This is done by setting the `schedule_time` to `now` and the `exit_status` to -1.
+    Cancelling a task means it will no longer be scheduled. This is done by setting the
+    `schedule_time` and `completion_time` to `now` and the `exit_status` to -1. The task
+    becomes terminal: it will not be scheduled, retried, or reverted on ``--restart``.
     A task cannot be cancelled after it is sent to remote clients.
 
 ``--revert``

{hypershell-2.8.0 → hypershell-2.8.2}/docs/index.rst

@@ -11,7 +11,7 @@ Release v\ |release| (:ref:`Getting Started <getting_started>`)
     :target: https://github.com/hypershell/hypershell/releases
     :alt: Github Release
 
-.. image:: https://img.shields.io/badge/Python-3.9+-blue.svg
+.. image:: https://img.shields.io/badge/Python-3.11+-blue.svg
     :target: https://www.python.org/downloads
     :alt: Python Versions
 

{hypershell-2.8.0 → hypershell-2.8.2}/docs/install.rst

@@ -257,11 +257,9 @@ managed by some `module` system.
 
 Here we will create an isolated prefix for the installation with version number included
 and only expose the entry-point scripts to users, along with shell completions and the
-manual page. Some desired runtime, ``python3.13``, is already loaded.
-
-If there is not already a preferred Python module it might be easier to use
-`conda-forge <https://conda-forge.org>`_ (or `mamba <https://mamba.readthedocs.io>`_)
-or ``uv`` directly to create a virtual environment.
+manual page. We can either use an existing Python runtime installed externally, otherwise
+`conda-forge <https://conda-forge.org>`_ has the added benefit of complete isolation and
+the ``psycopg-c`` dependencies for maximum security and performance.
 
 .. admonition:: Create installation manually on a shared system
     :class: note
@@ -271,15 +269,16 @@ or ``uv`` directly to create a virtual environment.
         mkdir -p /apps/x86_64-any/hypershell/$VERSION
         cd /apps/x86_64-any/hypershell/$VERSION
 
-        git clone --depth=1 --branch=$VERSION https://github.com/hypershell/hypershell src
+        PKG='hypershell[postgres-system,uuid7,cron,zstd]'
+        URL='https://github.com/hypershell/hypershell'
 
-        python3.13 -m venv libexec
-        libexec/bin/pip install './src[postgres]'
+        python3.14 -m venv libexec
+        libexec/bin/pip install "$PKG @ git+$URL@$VERSION"
 
         mkdir -p bin
-        ln -sf ../libexec/bin/hs bin/hs
-        ln -sf ../libexec/bin/hsx bin/hsx
-        ln -sf src/share
+        cd bin
+        ln -sf ../libexec/bin/hs
+        ln -sf ../libexec/bin/hsx
 
 |
 
@@ -303,10 +302,13 @@ configuration file might then be:
 
         prepend_path("PATH", pathJoin(modroot, "bin"))
         prepend_path("MANPATH", pathJoin(modroot, "share", "man"))
-        prepend_path("FPATH", pathJoin(modroot, "share", "zsh", "site-functions"))  -- Zsh completions
 
-        -- Raw source b/c `complete -F _hs hs` does not persist with source_sh
-        execute { cmd="source " .. pathJoin(modroot, "share", "bash_completion.d", "hs"), modeA={"load"} }
+        if myShellName() == "bash" then
+                source_sh("bash", pathJoin(modroot, "libexec", "share", "bash-completion", "completions", "hs"))
+        elseif myShellName() == "zsh" then
+                prepend_path("FPATH", pathJoin(modroot, "libexec", "share", "zsh", "site-functions"))
+                execute({ cmd = "autoload -Uz compinit && compinit", modeA = { "load" } })
+        end
 
 Presumably, users would then be able to activate the software by loading the module as such.
 
@@ -344,9 +346,9 @@ And we can include the following paths in our frozen set.
 
     .. code-block:: shell
 
-        /apps/x86_64-any/hypershell/<version>/libexec/lib/python3.13
-        /apps/x86_64-any/hypershell/<version>/libexec/lib/python3.13/lib-dynload
-        /apps/x86_64-any/hypershell/<version>/libexec/lib/python3.13/site-packages
+        /apps/x86_64-any/hypershell/<version>/libexec/lib/python3.14
+        /apps/x86_64-any/hypershell/<version>/libexec/lib/python3.14/lib-dynload
+        /apps/x86_64-any/hypershell/<version>/libexec/lib/python3.14/site-packages
 
 
 ------

{hypershell-2.8.0 → hypershell-2.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hypershell"
-version = "2.8.0"
+version = "2.8.2"
 description = "A cross-platform, high-throughput computing utility for processing shell commands over a distributed, asynchronous queue."
 readme = "README.rst"
 license = "Apache-2.0"

{hypershell-2.8.0 → hypershell-2.8.2}/share/man/man1/hs.1

@@ -28,7 +28,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "HS" "1" "Jul 05, 2026" "2.8.0" "hypershell"
+.TH "HS" "1" "Jul 22, 2026" "2.8.2" "hypershell"
 .SH NAME
 hs \- Process shell commands over a distributed, asynchronous queue
 .SH SYNOPSIS
@@ -1360,7 +1360,9 @@ Include any number of \fIFIELD=VALUE\fP or tag \fIKEY:VALUE\fP positional argume
 .sp
 The \fB\-w\fP/\fB\-\-where\fP and \fB\-t\fP/\fB\-\-with\-tag\fP operate just as in the search command.
 .sp
-Using \fB\-\-cancel\fP sets \fIschedule_time\fP to now and \fIexit_status\fP to \-1.
+Using \fB\-\-cancel\fP marks tasks as cancelled: \fIschedule_time\fP and \fIcompletion_time\fP
+are set to now and \fIexit_status\fP to \-1. A cancelled task is terminal \- it will not be
+scheduled, retried, or reverted on \fB\-\-restart\fP\&.
 .sp
 Using \fB\-\-revert\fP reverts everything as if the task was new again.
 .sp
@@ -1380,8 +1382,9 @@ Assignment pairs for update.
 .B \fB\-\-cancel\fP
 Cancel specified tasks.
 .sp
-Cancelling a task means it will no longer be scheduled.
-This is done by setting the \fIschedule_time\fP to \fInow\fP and the \fIexit_status\fP to \-1.
+Cancelling a task means it will no longer be scheduled. This is done by setting the
+\fIschedule_time\fP and \fIcompletion_time\fP to \fInow\fP and the \fIexit_status\fP to \-1. The task
+becomes terminal: it will not be scheduled, retried, or reverted on \fB\-\-restart\fP\&.
 A task cannot be cancelled after it is sent to remote clients.
 .TP
 .B \fB\-\-revert\fP

{hypershell-2.8.0 → hypershell-2.8.2}/share/man/man1/hsx.1

@@ -28,7 +28,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "HS" "1" "Jul 05, 2026" "2.8.0" "hypershell"
+.TH "HS" "1" "Jul 22, 2026" "2.8.2" "hypershell"
 .SH NAME
 hs \- Process shell commands over a distributed, asynchronous queue
 .SH SYNOPSIS
@@ -1360,7 +1360,9 @@ Include any number of \fIFIELD=VALUE\fP or tag \fIKEY:VALUE\fP positional argume
 .sp
 The \fB\-w\fP/\fB\-\-where\fP and \fB\-t\fP/\fB\-\-with\-tag\fP operate just as in the search command.
 .sp
-Using \fB\-\-cancel\fP sets \fIschedule_time\fP to now and \fIexit_status\fP to \-1.
+Using \fB\-\-cancel\fP marks tasks as cancelled: \fIschedule_time\fP and \fIcompletion_time\fP
+are set to now and \fIexit_status\fP to \-1. A cancelled task is terminal \- it will not be
+scheduled, retried, or reverted on \fB\-\-restart\fP\&.
 .sp
 Using \fB\-\-revert\fP reverts everything as if the task was new again.
 .sp
@@ -1380,8 +1382,9 @@ Assignment pairs for update.
 .B \fB\-\-cancel\fP
 Cancel specified tasks.
 .sp
-Cancelling a task means it will no longer be scheduled.
-This is done by setting the \fIschedule_time\fP to \fInow\fP and the \fIexit_status\fP to \-1.
+Cancelling a task means it will no longer be scheduled. This is done by setting the
+\fIschedule_time\fP and \fIcompletion_time\fP to \fInow\fP and the \fIexit_status\fP to \-1. The task
+becomes terminal: it will not be scheduled, retried, or reverted on \fB\-\-restart\fP\&.
 A task cannot be cancelled after it is sent to remote clients.
 .TP
 .B \fB\-\-revert\fP

{hypershell-2.8.0 → hypershell-2.8.2}/share/man/man1/hyper-shell.1

@@ -28,7 +28,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "HYPER-SHELL" "1" "Jul 05, 2026" "2.8.0" "hypershell"
+.TH "HYPER-SHELL" "1" "Jul 22, 2026" "2.8.2" "hypershell"
 .SH NAME
 hyper-shell \- Process shell commands over a distributed, asynchronous queue
 .SH SYNOPSIS
@@ -1360,7 +1360,9 @@ Include any number of \fIFIELD=VALUE\fP or tag \fIKEY:VALUE\fP positional argume
 .sp
 The \fB\-w\fP/\fB\-\-where\fP and \fB\-t\fP/\fB\-\-with\-tag\fP operate just as in the search command.
 .sp
-Using \fB\-\-cancel\fP sets \fIschedule_time\fP to now and \fIexit_status\fP to \-1.
+Using \fB\-\-cancel\fP marks tasks as cancelled: \fIschedule_time\fP and \fIcompletion_time\fP
+are set to now and \fIexit_status\fP to \-1. A cancelled task is terminal \- it will not be
+scheduled, retried, or reverted on \fB\-\-restart\fP\&.
 .sp
 Using \fB\-\-revert\fP reverts everything as if the task was new again.
 .sp
@@ -1380,8 +1382,9 @@ Assignment pairs for update.
 .B \fB\-\-cancel\fP
 Cancel specified tasks.
 .sp
-Cancelling a task means it will no longer be scheduled.
-This is done by setting the \fIschedule_time\fP to \fInow\fP and the \fIexit_status\fP to \-1.
+Cancelling a task means it will no longer be scheduled. This is done by setting the
+\fIschedule_time\fP and \fIcompletion_time\fP to \fInow\fP and the \fIexit_status\fP to \-1. The task
+becomes terminal: it will not be scheduled, retried, or reverted on \fB\-\-restart\fP\&.
 A task cannot be cancelled after it is sent to remote clients.
 .TP
 .B \fB\-\-revert\fP

{hypershell-2.8.0 → hypershell-2.8.2}/src/hypershell/core/config.py

@@ -225,7 +225,7 @@ def partial_load(system: Optional[str] = path.system.config,
         'default': default, **preload,
         'system': {} if not system else load_file(system),
         'user': {} if not user else load_file(user),
-        'local': {} if not user else load_file(local),
+        'local': {} if not local else load_file(local),
         'env': load_env(),
     })
 

{hypershell-2.8.0 → hypershell-2.8.2}/src/hypershell/core/exceptions.py

@@ -28,7 +28,7 @@ from hypershell.core.platform import default_path
 # Public interface
 __all__ = ['display_warning', 'display_error', 'display_critical', 'traceback_filepath', 'write_traceback',
            'handle_exception', 'handle_exception_silently', 'handle_disconnect', 'handle_address_unknown',
-           'HostAddressInfo', 'DatabaseUninitialized',
+           'handle_broken_pipe', 'HostAddressInfo', 'DatabaseUninitialized',
            'get_shared_exception_mapping', ]
 
 
@@ -96,6 +96,24 @@ def handle_exception_silently(exc: Exception) -> int:
     return status
 
 
+def handle_broken_pipe(exc: Exception) -> int:  # noqa: unused exc
+    """Handle a downstream reader closing the pipe early (e.g. `hs list | head`).
+
+    Python replaces the POSIX ``SIGPIPE`` with a `BrokenPipeError` rather than terminating the
+    process, so we catch it here instead of dumping a traceback - the consumer simply stopped
+    reading, which is not an error. A bare exit would raise a *second* `BrokenPipeError` when the
+    interpreter flushes ``stdout`` at shutdown, so we redirect the ``stdout`` file descriptor to
+    the null device to discard that final flush. Cross-platform: no reliance on ``SIGPIPE``
+    (absent on Windows), and the process signal disposition is left untouched.
+    """
+    try:
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+    except (OSError, ValueError):
+        pass  # stdout may lack a real file descriptor (already closed or replaced)
+    return exit_status.success
+
+
 def handle_address_unknown(exc: Exception,  # noqa: unused
                            logger: logging.Logger,
                            status: int = exit_status.runtime_error) -> int:

{hypershell-2.8.0 → hypershell-2.8.2}/src/hypershell/data/model.py

@@ -25,7 +25,7 @@ from sqlalchemy.dialects.postgresql import SMALLINT, UUID as POSTGRES_UUID, JSON
 # Internal libs
 from hypershell.core.logging import Logger, HOSTNAME, INSTANCE
 from hypershell.core.heartbeat import Heartbeat
-from hypershell.core.types import JSONData, to_json_type, from_json_type, serialize, deserialize
+from hypershell.core.types import JSONData, to_json_type, from_json_type, serialize, deserialize, parse_bytes
 from hypershell.core.uuid import uuid
 from hypershell.core.tag import Tag
 from hypershell.data.core import schema, Session
@@ -34,7 +34,7 @@ from hypershell.data.core import schema, Session
 __all__ = [
     'Task', 'Client', 'Entity', 'to_json_type', 'from_json_type', 'serialize_tasks', 'deserialize_tasks',
     'UUID', 'TEXT', 'INTEGER', 'SMALL_INTEGER', 'DATETIME', 'BOOLEAN', 'JSON',
-    'DEFAULT_TASK_GROUP', 'TaskGroupInfo',
+    'DEFAULT_TASK_GROUP', 'CANCEL_STATUS', 'TaskGroupInfo',
 ]
 
 # Initialize logger
@@ -45,6 +45,15 @@ log = Logger.with_name(__name__)
 DEFAULT_TASK_GROUP: Final[int] = 0
 """Default task group for backwards compatibility."""
 
+CANCEL_STATUS: Final[int] = -1
+"""Sentinel `exit_status` marking a cancelled task.
+
+A cancelled task is terminal: it must never be scheduled, retried, or counted as an
+unrecoverable failure. It is distinguished from a genuine failure (positive exit codes,
+or the negative template/resource sentinels in `client.py`) solely by this value, so the
+scheduler's failure and retry queries filter it out explicitly.
+"""
+
 
 class DatabaseError(Exception):
     """Generic database-related exception."""
@@ -335,7 +344,11 @@ class Task(Entity):
         tag = {**(tag or {}), **inline_tags, **{'part': 0, }}
         other['group'] = tag.pop('group', group)
         other['cores'] = tag.pop('cores', other.get('cores', None))
-        other['memory'] = tag.pop('memory', other.get('memory', None))
+        # A memory value may arrive as a unit-bearing string ('2GB') from an inline
+        # `memory:` tag (parsed by smart_coerce, which leaves units alone) — parse it to
+        # integer bytes as the `--memory` flag does, so resource accounting stays numeric.
+        memory = tag.pop('memory', other.get('memory', None))
+        other['memory'] = parse_bytes(memory) if isinstance(memory, str) else memory
         other['timeout'] = tag.pop('timeout', other.get('timeout', None))
         return Task(id=uuid(), args=args,
                     submit_id=INSTANCE, submit_host=HOSTNAME, submit_time=datetime.now().astimezone(),
@@ -437,6 +450,7 @@ class Task(Entity):
             .filter(Task.group == previous_group)
             .filter(cls.exit_status.isnot(None))
             .filter(cls.exit_status != 0)
+            .filter(cls.exit_status != CANCEL_STATUS)  # NOTE: cancelled is terminal, not a failure
             .filter(cls.attempt >= attempts)
             .filter(cls.retried.is_(False))
         )
@@ -472,6 +486,7 @@ class Task(Entity):
                  .order_by(cls.completion_time)
                  .filter(cls.exit_status.isnot(None))
                  .filter(cls.exit_status != 0)
+                 .filter(cls.exit_status != CANCEL_STATUS)  # NOTE: cancelled is terminal, not a failure
                  .filter(cls.attempt < attempts)
                  .filter(cls.retried.is_(False)))
         if group is not None:
@@ -605,11 +620,15 @@ class Task(Entity):
     @classmethod
     def cancel_all(cls: Type[Task], ids: List[str]) -> None:
         """Cancel all tasks identified by `ids`."""
+        # NOTE: completion_time is set so the task is terminal - otherwise it reads as
+        # "interrupted" (scheduled but incomplete) and gets reverted/re-run on restart.
+        now = datetime.now().astimezone()
         cls.update_all([
             {
                 'id': id,
-                'schedule_time': datetime.now().astimezone(),
-                'exit_status': -1,
+                'schedule_time': now,
+                'completion_time': now,
+                'exit_status': CANCEL_STATUS,
              }
             for id in ids
         ])

{hypershell-2.8.0 → hypershell-2.8.2}/src/hypershell/task.py

@@ -37,14 +37,15 @@ from sqlalchemy.sql.elements import BinaryExpression
 # Internal libs
 from hypershell.core.platform import default_path
 from hypershell.core.config import config
-from hypershell.core.exceptions import handle_exception, handle_exception_silently, get_shared_exception_mapping
+from hypershell.core.exceptions import (handle_exception, handle_exception_silently, handle_broken_pipe,
+                                        get_shared_exception_mapping)
 from hypershell.core.logging import Logger, HOSTNAME
 from hypershell.core.remote import SSHConnection
 from hypershell.core.types import smart_coerce, JSONData, to_json_type
 from hypershell.core.pretty_print import format_tag, format_json, format_bytes
 from hypershell.core.tag import Tag
 from hypershell.data.core import Session
-from hypershell.data.model import Task, JSON
+from hypershell.data.model import Task, JSON, CANCEL_STATUS
 from hypershell.data import ensuredb, DATABASE_DIALECT
 
 # Public interface
@@ -177,6 +178,7 @@ class TaskInfoApp(Application):
 
     exceptions = {
         Task.NotFound: functools.partial(handle_exception, logger=log, status=exit_status.runtime_error),
+        BrokenPipeError: handle_broken_pipe,  # e.g. `hs info UUID --stdout | head`
         **get_shared_exception_mapping(__name__)
     }
 
@@ -641,6 +643,7 @@ class TaskSearchApp(Application, SearchableMixin):
 
     exceptions = {
         StatementError: functools.partial(handle_exception, logger=log, status=exit_status.runtime_error),
+        BrokenPipeError: handle_broken_pipe,  # e.g. `hs list --all --csv | head`
         **get_shared_exception_mapping(__name__)
     }
 
@@ -820,7 +823,8 @@ UPDATE_HELP = f"""\
   Include any number of FIELD=VALUE or tag KEY:VALUE positional arguments.
   The -w/--where and -t/--with-tag operate just as in the search command.
 
-  Using --cancel sets schedule_time to now and exit_status to {CANCEL_STATUS}. 
+  Using --cancel marks tasks terminal (schedule_time and completion_time to now,
+  exit_status to {CANCEL_STATUS}); they will not be scheduled, retried, or reverted.
   Using --revert reverts everything as if the task was new again.
   Using --delete drops the row from the database entirely.
 
@@ -980,7 +984,11 @@ class TaskUpdateApp(Application, SearchableMixin):
                 prev_count = query.filter(Task.schedule_time.isnot(None)).count()
             if prev_count > 0:
                 log.warning(f'{prev_count} cancelled tasks already scheduled')
-            field_updates['schedule_time'] = datetime.now().astimezone()
+            # NOTE: completion_time is set so the task is terminal - otherwise it reads as
+            # "interrupted" (scheduled but incomplete) and gets reverted/re-run on restart.
+            now = datetime.now().astimezone()
+            field_updates['schedule_time'] = now
+            field_updates['completion_time'] = now
             field_updates['exit_status'] = CANCEL_STATUS
 
         if self.revert_mode:

hypershell-2.8.2/tests/test_cancel.py

@@ -0,0 +1,100 @@
+# SPDX-FileCopyrightText: 2026 Geoffrey Lentner
+# SPDX-License-Identifier: Apache-2.0
+
+"""Test task cancellation is terminal and never re-scheduled by the server."""
+
+
+# Type annotations
+from __future__ import annotations
+
+# Standard libs
+import re
+from pathlib import Path
+
+# External libs
+from pytest import mark
+from cmdkit.app import exit_status
+
+# Internal libs
+from tests import main, main_lines, create_taskfile
+
+
+def submit_pending(temp_site: Path, count: int) -> None:
+    """Submit `count` uniquely-tagged echo tasks to the database as pending (not run)."""
+    tasks = [f'echo RUN_{n}  # HYPERSHELL: n:{n}' for n in range(count)]
+    taskfile = create_taskfile(temp_site, tasks)
+    rc, _, _ = main(['hs', 'submit', str(taskfile)])
+    assert rc == exit_status.success
+
+
+@mark.integration
+def test_cancel_is_terminal(temp_site: Path) -> None:
+    """Cancelling a task marks it terminal: exit_status is the sentinel and completion_time is set.
+
+    A cancelled task that only had `schedule_time`/`exit_status` set (but no `completion_time`)
+    reads as "interrupted" to the scheduler and gets reverted/re-run - so completion_time
+    must be populated for the cancellation to stick.
+    """
+    submit_pending(temp_site, 3)
+
+    rc, _, _ = main(['hs', 'update', '--cancel', '-t', 'n:1', '--no-confirm'])
+    assert rc == exit_status.success
+
+    rc, out, _ = main_lines(['hs', 'list', 'exit_status', '-t', 'n:1'])
+    assert out == ['-1']
+
+    rc, out, _ = main_lines(['hs', 'list', 'completion_time', '-t', 'n:1'])
+    assert out not in (['null'], [''])
+
+
+@mark.integration
+def test_cancelled_task_not_reverted_on_restart(temp_site: Path) -> None:
+    """A cancelled task must not be reverted and re-run by `hs cluster --restart`.
+
+    Regression: `--cancel` left `completion_time` NULL, so `revert_interrupted()` on restart
+    treated the cancellation-set `schedule_time` as an interruption, reverted the task, and
+    re-ran it (flipping exit_status from the cancel sentinel to 0).
+    """
+    submit_pending(temp_site, 4)
+
+    rc, _, _ = main(['hs', 'update', '--cancel', '-t', 'n:2', '--no-confirm'])
+    assert rc == exit_status.success
+
+    rc, stdout, _ = main(['hs', 'cluster', '--restart'])
+    assert rc == exit_status.success
+
+    # The pending tasks run; the cancelled one does not.
+    assert set(re.findall(r'RUN_\d', stdout)) == {'RUN_0', 'RUN_1', 'RUN_3'}
+    assert 'RUN_2' not in stdout
+
+    # It remains cancelled, not completed successfully.
+    rc, out, _ = main_lines(['hs', 'list', 'exit_status', '-t', 'n:2'])
+    assert out == ['-1']
+
+
+@mark.integration
+def test_cancelled_task_not_retried(temp_site: Path) -> None:
+    """A cancelled task must not be picked up as a "failed" task for retry.
+
+    Regression: the retry query (`select_failed`) matched any `exit_status != 0`, so with
+    retries enabled the cancel sentinel (-1) looked like a failure and was re-scheduled.
+    """
+    submit_pending(temp_site, 3)
+
+    rc, _, _ = main(['hs', 'update', '--cancel', '-t', 'n:2', '--no-confirm'])
+    assert rc == exit_status.success
+
+    # File-mode cluster (not --restart, so no revert path) with retries enabled: once the
+    # pending tasks are exhausted the failed-task retry query runs - it must skip the cancelled task.
+    extra = create_taskfile(temp_site, ['echo EXTRA  # HYPERSHELL: m:0'], filename='extra.in')
+    rc, stdout, _ = main(['hs', 'cluster', str(extra), '-r2'])
+    assert rc == exit_status.success
+
+    assert 'RUN_2' not in stdout
+
+    rc, out, _ = main_lines(['hs', 'list', 'exit_status', '-t', 'n:2'])
+    assert out == ['-1']
+
+    # No retry copy was created (a retry would add a second row with attempt=2).
+    rc, out, _ = main_lines(['hs', 'list', 'attempt', '-t', 'n:2'])
+    assert out == ['1']

{hypershell-2.8.0 → hypershell-2.8.2}/tests/test_submit.py

@@ -18,6 +18,7 @@ from cmdkit.app import exit_status
 # Internal libs
 from tests import main, main_lines, NO_OUTPUT, create_taskfile_echo, assert_output, UUID_PATTERN
 from hypershell.submit import SubmitApp
+from hypershell.data.model import Task
 
 
 @mark.integration
@@ -213,3 +214,24 @@ def test_submit_bundled(temp_site: Path) -> None:
     assert main_lines(['hs', 'list', 'args', '-f', 'plain', '-s', 'submit_time']) == (
         exit_status.success, [f'echo {n}' for n in range(100)], NO_OUTPUT
     )
+
+
+@mark.unit
+def test_inline_memory_tag_parses_units_to_bytes() -> None:
+    """An inline ``memory:<size>`` resource tag is parsed to integer bytes — like the ``--memory``
+    flag (parse_bytes) — not stored as a raw string.
+
+    smart_coerce (used for inline tag values) leaves unit-bearing strings like ``2GB`` untouched, so
+    without explicit parsing ``Task.memory`` would be a string and client-side resource accounting
+    (``memory_total < task.memory``, an int vs str comparison) crashes.
+    """
+    # The reported form: an inline HYPERSHELL comment carrying a unit suffix.
+    task = Task.new(args='echo AAA #HYPERSHELL: cores:1 memory:2GB timeout:10')
+    assert task.memory == 2147483648            # 2 * 1024**3
+    assert task.cores == 1 and task.timeout == 10
+    # The tag= kwarg form resolves identically.
+    assert Task.new(args='echo', tag={'memory': '512MB'}).memory == 536870912
+    # Unit-less, already-integer, and absent values are unaffected (no regression).
+    assert Task.new(args='echo', tag={'memory': '2000'}).memory == 2000
+    assert Task.new(args='echo', tag={'memory': 4096}).memory == 4096
+    assert Task.new(args='echo').memory is None