claude-dev-env 8.98.0 → 8.98.2

package/hooks/blocking/open_tasks_stop_gate.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 """Stop hook that keeps a session working while its task list has unreported open items.
 
-The session's open items merge these sources, one item per subject::
+The session's open items merge these sources. A transcript item whose subject
+the task store holds is dropped, so the task store wins; every other item stays::
 
     ~/.claude/tasks/<task list id>/*.json        (TaskCreate / TaskUpdate store)
     transcript TaskCreate / TaskUpdate calls      (replayed in order)
@@ -207,13 +208,22 @@ def is_dropped_carried_item(task_item: TaskItem, all_prompts: list[RecordedPromp
     )
 
 
-def deduplicated_by_subject(all_items: list[TaskItem]) -> list[TaskItem]:
-    """Keep the first item for each subject, so the task store wins over the transcript."""
-    item_by_key: dict[str, TaskItem] = {}
-    for each_item in all_items:
-        item_key = normalized_text(each_item.subject) or TASK_NUMBER_REFERENCE_TEMPLATE.format(task_id=each_item.item_id)
-        item_by_key.setdefault(item_key, each_item)
-    return list(item_by_key.values())
+def _subject_key(task_item: TaskItem) -> str:
+    return normalized_text(task_item.subject) or TASK_NUMBER_REFERENCE_TEMPLATE.format(task_id=task_item.item_id)
+
+
+def deduplicated_by_subject(all_sources: list[list[TaskItem]]) -> list[TaskItem]:
+    """Drop an item whose subject an earlier source holds, so the task store wins over the transcript.
+
+    The caller passes the task store and the whole transcript as two sources. Items inside one source all
+    stay, so a pending task keeps its place beside a completed task of the same subject.
+    """
+    all_kept_items: list[TaskItem] = []
+    all_earlier_keys: set[str] = set()
+    for each_source in all_sources:
+        all_kept_items.extend(each_item for each_item in each_source if _subject_key(each_item) not in all_earlier_keys)
+        all_earlier_keys.update(_subject_key(each_item) for each_item in each_source)
+    return all_kept_items
 
 
 def unreported_open_items(all_hook_input_fields: dict[str, object]) -> list[TaskItem]:
@@ -230,7 +240,7 @@ def unreported_open_items(all_hook_input_fields: dict[str, object]) -> list[Task
         if not is_dropped_carried_item(each_item, all_prompts, all_closing_texts)
     ]
     all_items = [
-        *deduplicated_by_subject([*(task_store_items(session_id) or []), *all_replayed_items]),
+        *deduplicated_by_subject([task_store_items(session_id) or [], all_replayed_items]),
         *open_ask_items(all_prompts, all_closing_texts),
     ]
     return [

package/hooks/blocking/pr_lifecycle_skill_gate.py

@@ -81,7 +81,7 @@ def _command_segments(command: str) -> list[list[str]]:
     except ValueError:
         return []
     for each_word in all_words:
-        if each_word[0] in COMMAND_SEPARATORS:
+        if each_word and each_word[0] in COMMAND_SEPARATORS:
             all_segments.append(each_segment)
             each_segment = []
             continue

package/hooks/blocking/test_open_tasks_stop_gate.py

@@ -402,6 +402,19 @@ def test_should_hold_an_ask_whose_subject_matches_a_completed_task(
     assert "#ask-1: Fix login" in reason_text
 
 
+def test_should_hold_a_pending_task_that_shares_a_subject_with_a_completed_task(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    write_task_store(
+        tmp_path,
+        [
+            {"id": "1", "subject": "Run tests", "status": "completed"},
+            {"id": "2", "subject": "Run tests", "status": "pending"},
+        ],
+    )
+    assert "Run tests" in block_reason(monkeypatch, capsys, "Done.")
+
+
 def test_should_record_nothing_for_a_question_only_prompt(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:

package/hooks/blocking/test_pr_lifecycle_skill_gate.py

@@ -74,6 +74,10 @@ def test_executable_word_lists_reads_chains_prefixes_and_shell_wrappers() -> Non
     assert gate.executable_word_lists("bash -c 'git add x; git commit'")[-2:] == [["git", "add", "x"], ["git", "commit"]]
 
 
+def test_executable_word_lists_keeps_an_empty_quoted_argument() -> None:
+    assert gate.executable_word_lists('git commit -m ""') == [["git", "commit", "-m", ""]]
+
+
 def test_loaded_skill_allows_action_silently(tmp_path: Path) -> None:
     path = _transcript(tmp_path, "plugin:pr-lifecycle")
     assert _run_main(_payload("gh pr view", path)) == (0, "")

package/hooks/features/conduct-gates.md

@@ -6,7 +6,7 @@ This family stops a chat reply, edited message, or tool call when its payload br
 
 - `blocking/reply_length_gate.py` caps chat reply length, denies a configured banned word, requires a readable link when the text names a pull request number, and denies a causal claim in a reply that cites no code span, output block, or link. It denies a sentence that guesses, estimates, hedges a duration, or admits a skipped check, such as "I didn't confirm this one." It denies a cited Actions run, pull request, or run, job, or check id that no successful tool result in the transcript shows; a subagent's report is the result of its Agent call. A question card from `AskUserQuestion` gets the banned word check and `unvalidated_claim_violation`, like a decision card. With visual reply mode on, it also runs the checks in `visual_reply_rules.py` from the rule list in `rules/visual-reply-rules.json`: no abbreviation or tracker number outside a link, a widget or page before a reply of more than one sentence, and no anchor link inside widget code. The mode is off by default; `~/.claude/visual-reply-mode.json` with `{"enabled": true}` turns the mode checks on.
 - `blocking/final_reply_gate.py` applies the banned words, `unvalidated_claim_violation`, and `unseen_citation_violation` from the reply gate to the reply a session ends its turn with. Its `windows_path_violation` blocks a path the terminal would render without one of its backslashes.
-- `blocking/open_tasks_stop_gate.py` holds the end of a turn while the session has open items that the closing reply does not name on a `Blocked:` or `Open:` line. It merges the task store, the transcript task calls, the desktop `mcp__ccd_turn__update_plan` plan, and the recorded asks, one item per subject. `blocking/open_tasks_transcript.py` rebuilds the task list and the last reply from the transcript for it. Each new desktop plan list carries the unfinished items of the list before it after its own items, so `done` and `start` positions still point at its own items. An ask stays open until a reply line `Done: #ask-N` closes it. A line `Dropped: <#ask-N or carried item> - "<quote>"` closes an ask or a carried plan item when the quote is in a prompt the user sent after that ask or that list.
+- `blocking/open_tasks_stop_gate.py` holds the end of a turn while the session has open items that the closing reply does not name on a `Blocked:` or `Open:` line. It merges the task store, the transcript task calls, the desktop `mcp__ccd_turn__update_plan` plan, and the recorded asks. A transcript item whose subject the task store holds is dropped, and every other item stays. `blocking/open_tasks_transcript.py` rebuilds the task list and the last reply from the transcript for it. Each new desktop plan list carries the unfinished items of the list before it after its own items, so `done` and `start` positions still point at its own items. An ask stays open until a reply line `Done: #ask-N` closes it. A line `Dropped: <#ask-N or carried item> - "<quote>"` closes an ask or a carried plan item when the quote is in a prompt the user sent after that ask or that list.
 - `session/open_task_ask_recorder.py` records each prompt in `~/.claude/open-task-asks/<session id>.json`, outside the task store. A prompt that asks for work gets the next `#ask-N` id. A question-only prompt, an acknowledgement such as `thanks!`, an empty prompt, and a harness envelope such as `<task-notification>` get none.
 - The claim judge is a `prompt` hook in `hooks.json`, with no `model` set, so Claude Code's small default hook model reads each chat message and denies the first claim about how code, a file, a tool, a service, a run, or a process behaves, or why something happened, when nothing in the message shows it: inline code that quotes output or a code line, a file and line, or a link. A pull request link covers what that change does, what it blocks or lets through, and its checks. The author's own actions, a restatement of the user's words, questions, instructions, and a decision card's option consequences pass. It catches the plain claims the causal word list in `blocking/reply_length_gate.py` misses, such as "The code lets any of them rewrite it mid-check." `continueOnBlock` returns the reason to the agent as the tool error, so it can add the source and send again. The installer owns it through the `claude-dev-env: ` prefix on its `statusMessage`. It skips `post_widget`, whose input is SVG or HTML markup.
 - `blocking/chat_reply_gate.py` runs the `reply_length_gate.py` reply checks on a plain chat reply, which is no tool call. On `UserPromptSubmit` it adds the reply rules as `additionalContext`. On `MessageDisplay` it holds each streamed batch until the message ends. A message that passes shows whole. A message that fails shows as a draft from `claude -p` on Haiku that passes the same checks, and the original shows when two drafts fail. The draft changes only the text on screen, so the next `UserPromptSubmit` tells the agent the text the user saw, and `SessionEnd` deletes the stored draft. The [reply arena harness](https://github.com/jl-cmd-projects/claude-dev-env/tree/160349b90f627ea542fc6bc7b2b7f86dcbf98b73/tests/reply_arena) ran the comparison that chose this display path.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.98.0",
+    "version": "8.98.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {