@litfamily/lithermes 1.0.26 → 1.0.28

package/assets/lithermes-plugin/core_review.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import re
 from pathlib import Path
 
 try:
@@ -11,7 +12,7 @@ try:
         reader_facing_contract_block,
     )
     from .core_reader_args import parse_reader_facing_command_args
-    from .core_runtime import parse_args, record_delegate_batch_intent, workspace_from_option
+    from .core_runtime import parse_args, plan_dir, record_delegate_batch_intent, workspace_from_option
 except (ImportError, ModuleNotFoundError):
     from core_contract import (
         _skill_body_block,
@@ -20,7 +21,7 @@ except (ImportError, ModuleNotFoundError):
         reader_facing_contract_block,
     )
     from core_reader_args import parse_reader_facing_command_args
-    from core_runtime import parse_args, record_delegate_batch_intent, workspace_from_option
+    from core_runtime import parse_args, plan_dir, record_delegate_batch_intent, workspace_from_option
 
 def _run_git(workspace: Path, args: list[str]) -> str:
     import subprocess
@@ -100,6 +101,72 @@ def detect_run_command(workspace: Path) -> str:
     return "(detect manually — no dev/start script found)"
 
 
+PLAN_REVIEW_LANES = [
+    ("scope-objective", "Scope and objective achievability — exactly one bounded objective, explicit non-goals, a scope small enough to reach one outcome. Verdict PASS/ITERATE/NEEDS-CONTEXT."),
+    ("dependencies-gates", "Dependencies and unknown gates — real prerequisites, acyclic ordering, resolved or gated unknowns, startable first-wave items. Verdict PASS/ITERATE/NEEDS-CONTEXT."),
+    ("atomic-checklist", "Atomic checklist — every item has one action, one output, one verification, references, dependencies, and a binary acceptance result. Verdict PASS/ITERATE/NEEDS-CONTEXT."),
+    ("acceptance-evidence", "Acceptance and evidence — success criteria map to exact artifacts and commands; negative and boundary evidence fits the risk. Verdict PASS/ITERATE/NEEDS-CONTEXT."),
+    ("failure-decision-cleanup", "Failure, decision and cleanup — alternative outcomes do not assume the preferred path; stop, rollback, cleanup and DoneClaim conditions are explicit. Verdict PASS/ITERATE/NEEDS-CONTEXT."),
+]
+
+# `lit review plan ...` / `/review-work plan ...` force plan review; `work` forces work review.
+_FORCED_MODE = re.compile(r"^\s*(?P<mode>plan|work)(?![\w-])\s*(?P<rest>.*)$", re.IGNORECASE | re.DOTALL)
+AUTO_PICK_RULE = (
+    "Review mode: auto-pick — work review when a named PR or diff, changed files outside plans/, or ticked plan rows "
+    "exist; plan review when a plan has no ticked rows and nothing else changed; ask the user when neither exists. "
+    "Name the picked mode on the first line of the report."
+)
+_PLAN_ROW = re.compile(r"^- \[(?P<mark>[ xX])\] ", re.MULTILINE)
+_STATE_PREFIXES = ("plans/", ".hermes/")
+
+
+def forced_review_mode(text: str) -> tuple[str | None, str]:
+    """Split a leading `plan`/`work` word off a review request."""
+    match = _FORCED_MODE.match(str(text or ""))
+    if match is None:
+        return None, str(text or "").strip()
+    return match.group("mode").lower(), match.group("rest").strip()
+
+
+def review_mode_line(objective: str) -> str:
+    mode, _ = forced_review_mode(objective)
+    return f"Review mode: {mode} (forced by the user)" if mode else AUTO_PICK_RULE
+
+
+def review_target(objective: str) -> str:
+    return forced_review_mode(objective)[1]
+
+
+def _plan_rows(workspace: Path) -> list[tuple[int, int]]:
+    """(ticked, total) checklist rows for each plan under plans/."""
+    rows: list[tuple[int, int]] = []
+    try:
+        files = sorted(plan_dir(workspace).glob("*.md"))[:20]
+    except OSError:
+        return rows
+    for file in files:
+        try:
+            marks = [m.group("mark") for m in _PLAN_ROW.finditer(file.read_text(encoding="utf-8")[:200_000])]
+        except OSError:
+            continue
+        rows.append((sum(mark != " " for mark in marks), len(marks)))
+    return rows
+
+
+def pick_review_mode(
+    forced: str | None, *, changed: list[str], plans: list[tuple[int, int]]
+) -> tuple[str, str]:
+    if forced:
+        return forced, "forced by the user"
+    if changed:
+        return "work", "auto-picked: changed files outside plans/"
+    if any(ticked for ticked, _ in plans):
+        return "work", "auto-picked: ticked plan rows"
+    if any(total for _, total in plans):
+        return "plan", "auto-picked: an unticked plan and no changed files"
+    return "ask", "no plan and no changed files found"
+
+
 REVIEW_LANES = [
     ("goal", "Goal & constraint verification — does the diff achieve the stated goal within every constraint; flag missed requirements, over-engineering, edge cases. Verdict PASS/FAIL + confidence."),
     ("qa", "QA by execution — brainstorm 15+ scenarios (happy/boundary/error/regression), then actually run the app/surface and capture evidence; tests alone are insufficient. Verdict PASS/FAIL with per-scenario results."),
@@ -109,11 +176,84 @@ REVIEW_LANES = [
 ]
 
 
+def _plan_or_ask_review(mode, mode_line, target, workspace, reader_args) -> dict[str, str]:
+    """Plan review dispatches the plan-audit lanes; ask dispatches nothing."""
+    parent_synthesis_contract = reader_facing_contract_block(
+        reader_args.requested_mode,
+        authority=reader_args.authority,
+        boundary="parent_synthesis",
+    )
+    if mode == "ask":
+        return {
+            "display": "LitHermes review-work: no plan and no changed files found. Asking what to review.",
+            "agent_message": "\n".join([
+                "<lithermes-review-work>",
+                contract_route_block("review-work", surface="slash-command"),
+                f"workspace: {workspace}",
+                mode_line,
+                "Ask the user one short question: review a plan (give its path) or review work (give a diff, branch or PR)?",
+                "Do not dispatch any lane and do not guess a target.",
+                "</lithermes-review-work>",
+                parent_synthesis_contract,
+            ]),
+        }
+    batch_event = record_delegate_batch_intent(
+        workspace=workspace,
+        mode="review-work",
+        lanes=[key for key, _ in PLAN_REVIEW_LANES],
+        context={"review_mode": "plan", "target": target},
+    )
+    child_return_contract = reader_facing_contract_block(
+        "audit",
+        authority="explicit_parent_to_child_return_mode",
+        boundary="subagent_to_parent_return",
+    )
+    lines = [
+        "Run the LitHermes plan review on the draft plan.",
+        "",
+        "<lithermes-review-work>",
+        contract_route_block("review-work", surface="slash-command"),
+        f"workspace: {workspace}",
+        mode_line,
+        f"plan under review: {target or '(newest file under plans/)'}",
+        f"delegate batch evidence: {batch_event.get('artifact_dir', '')}",
+        "",
+        "Plan review is read-only: audit the draft, never implement. Dispatch the five audit lanes in ONE",
+        "delegate_task call (a `tasks` array of 5 entries, each {goal: <lane brief>, context: <plan text>});",
+        "per-child re-entry receipts arrive as separate messages and there is no combined wait:",
+        *(f"- lane[{key}]: {brief}" for key, brief in PLAN_REVIEW_LANES),
+        "",
+        "Any NEEDS-CONTEXT controls the aggregate, then any ITERATE; all lanes must PASS for PLAN REVIEW PASS.",
+        "Name the mode on the first line of the report. Load the lithermes:review-work skill for the plan verdict contract.",
+        _skill_body_block("review-work"),
+        "The audit child-return packet stays detailed for review; it cannot elevate the parent response:",
+        child_return_contract,
+        "</lithermes-review-work>",
+        parent_synthesis_contract,
+    ]
+    return {
+        "display": "LitHermes review-work: plan review, 5 audit lanes. Dispatching parallel review now.",
+        "agent_message": "\n".join(lines),
+    }
+
+
 def command_review_work(raw_args: str) -> dict[str, str]:
     reader_args = parse_reader_facing_command_args(raw_args)
     args = parse_args(reader_args.command_args)
     workspace = workspace_from_option(args.options.get("worktree"))
-    base = str(args.options.get("base") or "HEAD~1")
+    explicit_base = args.options.get("base")
+    base = str(explicit_base or "HEAD~1")
+    forced, target = forced_review_mode(" ".join(args.positional))
+    # Older commits are not evidence of work to review: without --base only uncommitted changes count.
+    signal_paths = [] if forced else _changed_paths(workspace, str(explicit_base or "HEAD"))
+    mode, reason = pick_review_mode(
+        forced,
+        changed=[path for path in signal_paths if not path.startswith(_STATE_PREFIXES)],
+        plans=_plan_rows(workspace),
+    )
+    mode_line = f"Review mode: {mode} ({reason})"
+    if mode != "work":
+        return _plan_or_ask_review(mode, mode_line, target, workspace, reader_args)
     changed_paths = _changed_paths(workspace, base)
     diff = _run_git(workspace, ["diff", base])
     if len(diff) > 60000:
@@ -157,6 +297,7 @@ def command_review_work(raw_args: str) -> dict[str, str]:
         "<lithermes-review-work>",
         contract_route_block("review-work", surface="slash-command"),
         f"workspace: {workspace}",
+        mode_line,
         f"base: {base}",
         f"run command (for QA lane): {run_cmd}",
         f"delegate batch evidence: {batch_event.get('artifact_dir', '')}",

package/assets/lithermes-plugin/core_routing.py

@@ -87,6 +87,7 @@ _BARE_SKILL_PREFIXES = (
     ("wikify", "wikify"),
     ("litresearch", "litresearch"),
     ("lit-comprehend", "lit-comprehend"),
+    ("lit-brainstorm", "lit-brainstorm"),
     ("humanizer", "lit-humanizer"),
     ("lit-humanizer", "lit-humanizer"),
     ("comprehend", "lit-comprehend"),
@@ -136,6 +137,15 @@ _LIT_SKILL_SUFFIXES = (
     ("wikify", "wikify"),
     ("lit-comprehend", "lit-comprehend"),
     ("comprehend", "lit-comprehend"),
+    # Open-ask words. Safe HERE: the user already typed `lit`. They are not bare
+    # routes, because "idea" and "brainstorming" open ordinary sentences.
+    ("lit-brainstorm", "lit-brainstorm"),
+    ("brainstorm", "lit-brainstorm"),
+    ("brainstorming", "lit-brainstorm"),
+    ("ideation", "lit-brainstorm"),
+    ("ideate", "lit-brainstorm"),
+    ("idea", "lit-brainstorm"),
+    ("ideas", "lit-brainstorm"),
     ("comment-checker", "comment-checker"),
     ("lsp-setup", "lsp-setup"),
     ("lsp", "lsp"),

package/assets/lithermes-plugin/core_workflow_commands.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 try:
     from .core_commands import _join_positional
     from .core_contract import (
-        _skill_body_block, conditional_uiux_skill_blocks, contract_route_block,
+        LITGOAL_MEANING, _skill_body_block, conditional_uiux_skill_blocks, contract_route_block,
         reader_facing_contract_block,
     )
     from .core_plans import plan_structure_issues, unchecked_items
@@ -14,7 +14,7 @@ try:
 except (ImportError, ModuleNotFoundError):
     from core_commands import _join_positional
     from core_contract import (
-        _skill_body_block, conditional_uiux_skill_blocks, contract_route_block,
+        LITGOAL_MEANING, _skill_body_block, conditional_uiux_skill_blocks, contract_route_block,
         reader_facing_contract_block,
     )
     from core_plans import plan_structure_issues, unchecked_items
@@ -39,6 +39,7 @@ def command_litgoal(raw_args: str) -> dict[str, str]:
         "<lithermes-litgoal-command>",
         contract_route_block("litgoal", surface="slash-command"),
         f"workspace: {workspace}",
+        LITGOAL_MEANING,
         "Durable goal state lives under .hermes/lithermes/litgoal/ (goals.json + ledger.jsonl + evidence/).",
         "Drive it through the model-facing goal tools, not prose:",
         "- goal_status to read the active objective, criteria, evidence, and quality gate;",

package/assets/lithermes-plugin/deliverable_hedge_guard.py

@@ -15,6 +15,7 @@ this instructs a rebuild; it cannot refuse the write.
 from __future__ import annotations
 
 import difflib
+import errno
 import json
 import os
 import re
@@ -171,22 +172,50 @@ def _directory_flags() -> int | None:
     return os.O_RDONLY | directory | nofollow | getattr(os, "O_CLOEXEC", 0)
 
 
-def _relative_artifact_path(path_text: str, workspace: Path) -> Path | None:
+def _project_root() -> Path | None:
+    """The Hermes launch directory (this process's cwd), widened to the git toplevel above it."""
+    try:
+        launch = Path(os.getcwd()).resolve(strict=True)
+    except (OSError, RuntimeError):
+        return None
+    return next((folder for folder in (launch, *launch.parents) if (folder / ".git").exists()), launch)
+
+
+def _locate_artifact(path_text: str, workspace: Path) -> tuple[Path, Path] | None:
+    """(read root, path under it) for a reader copy, or None for internal and non-reader paths.
+
+    A path outside the working directory (absolute, or ``../`` after a terminal ``cd``) is
+    still a deliverable when it lies inside the launch project: it is judged by its path
+    under the project and read under its own parent. Anything outside both is skipped.
+    """
     candidate = Path(path_text).expanduser()
     target = candidate if candidate.is_absolute() else workspace / candidate
     absolute = Path(os.path.abspath(os.fspath(target)))
     try:
-        relative = absolute.relative_to(workspace)
+        root, relative = workspace, absolute.relative_to(workspace)
+        judged = relative
     except ValueError:
-        return None
+        project = _project_root()
+        root, relative = Path(os.path.realpath(absolute.parent)), Path(absolute.name)
+        try:
+            judged = (root / relative).relative_to(project) if project else None
+        except ValueError:
+            judged = None
+        if judged is None:
+            return None
     if (
         not relative.parts
         or any(part in {"", ".", ".."} for part in relative.parts)
         or relative.suffix.lower() not in READER_FACING_SUFFIXES
-        or _INTERNAL_FILE.search(relative.as_posix())
+        or _INTERNAL_FILE.search(judged.as_posix())
     ):
         return None
-    return relative
+    return root, relative
+
+
+def _relative_artifact_path(path_text: str, workspace: Path) -> Path | None:
+    located = _locate_artifact(path_text, workspace)
+    return located[1] if located else None
 
 
 def _read_stable_file_result(
@@ -195,10 +224,11 @@ def _read_stable_file_result(
     byte_limit: int,
     max_file_bytes: int = MAX_FILE_BYTES,
 ) -> _StableFile | _ReadBudgetExceeded | None:
-    relative = _relative_artifact_path(path_text, workspace)
+    located = _locate_artifact(path_text, workspace)
     directory_flags = _directory_flags()
-    if relative is None or directory_flags is None or byte_limit < 0:
+    if located is None or directory_flags is None or byte_limit < 0:
         return None
+    workspace, relative = located
     read_limit = min(max_file_bytes, byte_limit)
     root_parts = tuple(part for part in workspace.parts if part != os.path.sep)
     directory_fds: list[int] = []
@@ -387,20 +417,31 @@ def _run_detector(text: str, path_text: str) -> list[dict] | None:
             or finding["line"] < 1
             or finding["line_end"] < finding["line"]
             or not isinstance(finding.get("match"), str)
+            or not isinstance(finding.get("lines", []), list)
+            or not all(isinstance(line, int) for line in finding.get("lines", []))
         ):
             return None
     return findings
 
 
+def _touches_changed(finding: dict, changed: set[int]) -> bool:
+    """A document-scope finding lists its occurrence lines; any other finding counts its whole span."""
+    if "lines" in finding:
+        return any(line in changed for line in finding["lines"])
+    return any(finding["line"] <= line <= finding["line_end"] for line in changed)
+
+
 def _changed_findings(text: str, path_text: str, changed: set[int], session_id: str) -> list[dict] | None:
     findings = _run_detector(_mask_exact_user_quotes(text, session_id), path_text)
     if findings is None:
         return None
-    return [
-        finding
-        for finding in findings
-        if any(finding["line"] <= line <= finding["line_end"] for line in changed)
-    ]
+    return [finding for finding in findings if _touches_changed(finding, changed)]
+
+
+NEGATION_ADVICE = (
+    "negation-cluster: several negations sit in one place. Say what the thing is first, then add the caveat once. "
+    "Example: write \"18,420 visits in total, including repeat visits\" instead of \"18,420 is not the number of residents\"."
+)
 
 
 def _block_message(findings: list[dict]) -> dict[str, str] | None:
@@ -409,9 +450,10 @@ def _block_message(findings: list[dict]) -> dict[str, str] | None:
         return None
     refs = ", ".join(f"{item['rule']}:{item['line']}" for item in blocks[:5])
     extra = f" (+{len(blocks) - 5})" if len(blocks) > 5 else ""
+    advice = f" {NEGATION_ADVICE}" if any(item["rule"] == "negation-cluster" for item in blocks) else ""
     return {
         "action": "block",
-        "message": f"LitHumanizer blocked {len(blocks)} block-tier finding(s) in added prose ({refs}{extra}). Revise the added wording; warnings remain contextual review signals.",
+        "message": f"LitHumanizer blocked {len(blocks)} block-tier finding(s) in added prose ({refs}{extra}). Revise the added wording; warnings remain contextual review signals.{advice}",
     }
 
 
@@ -420,6 +462,8 @@ def _warn_if_needed(session_id: str, findings: list[dict]) -> None:
     if warnings:
         refs = ", ".join(f"{item['rule']}:{item['line']}" for item in warnings[:5])
         _queue_advisory(session_id, f"LitHumanizer warning-tier review signal(s) in added prose: {refs}. Consider them in context; they are not a ban or authorship judgment.")
+        if any(item["rule"] == "negation-cluster" for item in warnings):
+            _queue_advisory(session_id, NEGATION_ADVICE)
 
 
 def _fail_open(session_id: str) -> None:
@@ -435,8 +479,12 @@ def _read_previous(path_text: str, workspace: Path) -> str | None:
             return None
     target = Path(path_text).expanduser()
     target = target if target.is_absolute() else workspace / target
-    if result is None and not target.exists() and not target.is_symlink():
-        return ""
+    try:
+        if result is None and not target.exists() and not target.is_symlink():
+            return ""
+    except OSError as error:
+        # No file can sit at a path the system refuses to name, so the whole edit is new text.
+        return "" if error.errno == errno.ENAMETOOLONG else None
     return None
 
 
@@ -450,7 +498,11 @@ def _check_text_change(session_id: str, path_text: str, proposed: str, workspace
     if previous is None:
         _fail_open(session_id)
         return None
-    if len(previous.encode("utf-8")) > MAX_DETECT_BYTES:
+    return _check_proposed(session_id, path_text, previous, proposed)
+
+
+def _check_proposed(session_id: str, path_text: str, previous: str, proposed: str) -> dict[str, str] | None:
+    if len(proposed.encode("utf-8")) > MAX_DETECT_BYTES or len(previous.encode("utf-8")) > MAX_DETECT_BYTES:
         _fail_open(session_id)
         return None
     changed = _changed_lines(previous, proposed)
@@ -464,33 +516,106 @@ def _check_text_change(session_id: str, path_text: str, proposed: str, workspace
     return _block_message(findings)
 
 
-def _patch_added_chunks(patch_text: str) -> list[tuple[str, str]]:
-    chunks: list[tuple[str, str]] = []
-    path = ""
-    kind = ""
-    added: list[str] = []
-
-    def flush() -> None:
-        nonlocal added
-        if path and kind in {"Add", "Update"} and added:
-            chunks.append((path, "\n".join(added)))
-        added = []
-
-    for line in patch_text.splitlines():
+def _patch_operations(patch_text: str) -> list[tuple[str, str, list[tuple[str, list[tuple[str, str]]]]]]:
+    """V4A Add/Update operations as (kind, path, hunks); a hunk is (context hint, [(prefix, line)])."""
+    operations: list[tuple[str, str, list[tuple[str, list[tuple[str, str]]]]]] = []
+    hunks: list[tuple[str, list[tuple[str, str]]]] | None = None
+    for raw in patch_text.split("\n"):
+        line = raw[:-1] if raw.endswith("\r") else raw
         header = _V4A_FILE.match(line)
         if header:
-            flush()
-            kind, path = header.group(1), header.group(2).strip()
-        elif _V4A_MOVE.match(line):
-            flush()
-        elif line.startswith("+++") or line.startswith("---"):
-            flush()
-        elif line.startswith("+"):
-            added.append(line[1:])
+            hunks = [] if header.group(1) in {"Add", "Update"} else None
+            if hunks is not None:
+                operations.append((header.group(1), header.group(2).strip(), hunks))
+        elif _V4A_MOVE.match(line) or line.startswith("*** "):
+            continue
+        elif hunks is None or not line or line.startswith(("+++", "---", "\\")):
+            continue
+        elif line.startswith("@@"):
+            hint = re.match(r"@@\s*(.+?)\s*@@", line)
+            hunks.append((hint.group(1) if hint else "", []))
         else:
-            flush()
-    flush()
-    return chunks
+            if not hunks:
+                hunks.append(("", []))
+            hunks[-1][1].append((line[0], line[1:]) if line[0] in "+- " else (" ", line))
+    return [(kind, path, [hunk for hunk in found if hunk[1]]) for kind, path, found in operations]
+
+
+def _apply_hunks(previous: str, hunks: list[tuple[str, list[tuple[str, str]]]]) -> str | None:
+    """Apply V4A hunks the way Hermes places them; None when a hunk does not match exactly once."""
+    text = previous
+    for hint, lines in hunks:
+        search = [content for prefix, content in lines if prefix != "+"]
+        replace = "\n".join(content for prefix, content in lines if prefix != "-")
+        if not search:
+            if hint and text.count(hint) > 1:
+                return None
+            if hint and hint in text:
+                eol = text.find("\n", text.find(hint))
+                text = text + "\n" + replace if eol == -1 else text[: eol + 1] + replace + "\n" + text[eol + 1 :]
+            else:
+                text = text.rstrip("\n") + "\n" + replace + "\n"
+            continue
+        pattern = "\n".join(search)
+        if not pattern.strip() or text.count(pattern) != 1:
+            return None
+        text = text.replace(pattern, replace, 1)
+    return text
+
+
+def _hunk_text(hunks: list[tuple[str, list[tuple[str, str]]]]) -> tuple[str, set[int]]:
+    """Context and added lines with a blank line at every hunk break; the added lines count as changed."""
+    lines: list[str] = []
+    changed: set[int] = set()
+    for _hint, hunk in hunks:
+        if lines:
+            lines.append("")
+        for prefix, content in hunk:
+            if prefix == "-":
+                continue
+            lines.append(content)
+            if prefix == "+":
+                changed.add(len(lines))
+    return "\n".join(lines) + "\n", changed
+
+
+def _check_patch_operation(
+    session_id: str, kind: str, path_text: str, hunks: list[tuple[str, list[tuple[str, str]]]], workspace: Path
+) -> dict[str, str] | None:
+    previous = _read_previous(path_text, workspace)
+    if previous is not None:
+        proposed = "\n".join(c for _h, hunk in hunks for p, c in hunk if p == "+") + "\n" if kind == "Add" else _apply_hunks(previous, hunks)
+        if proposed is not None:
+            return _check_proposed(session_id, path_text, previous, proposed)
+    text, changed = _hunk_text(hunks)
+    if not changed:
+        return None
+    if len(text.encode("utf-8")) > MAX_DETECT_BYTES:
+        _fail_open(session_id)
+        return None
+    findings = _changed_findings(text, path_text, changed, session_id)
+    if findings is None:
+        _fail_open(session_id)
+        return None
+    _warn_if_needed(session_id, findings)
+    return _block_message(findings)
+
+
+def _file_tool_base(task_id: object) -> str:
+    """The directory Hermes resolves a relative file-tool path against: the session cwd a terminal ``cd`` recorded."""
+    terminal = sys.modules.get("tools.terminal_tool")
+    session_cwd = getattr(terminal, "get_session_cwd", None)
+    if callable(session_cwd):
+        try:
+            recorded = session_cwd(str(task_id or "") or None)
+        except Exception:  # noqa: BLE001 - a host helper failure falls back to the next anchor
+            recorded = None
+        if isinstance(recorded, str) and os.path.isabs(recorded) and os.path.isdir(recorded):
+            return recorded
+    configured = os.environ.get("TERMINAL_CWD", "")
+    if os.path.isabs(configured) and os.path.isdir(configured):
+        return configured
+    return os.getcwd()
 
 
 def pre_tool_call(
@@ -499,6 +624,7 @@ def pre_tool_call(
     session_id: object,
     *,
     workspace: object = None,
+    task_id: object = None,
 ) -> dict[str, str] | None:
     """Block block-tier findings before Hermes persists a supported text edit."""
     name = str(tool_name or "")
@@ -507,7 +633,7 @@ def pre_tool_call(
     if not key or name not in {"write_file", "patch"}:
         return None
     try:
-        root = Path(workspace or Path.cwd()).expanduser().resolve(strict=True)
+        root = Path(workspace or _file_tool_base(task_id)).expanduser().resolve(strict=True)
     except (OSError, RuntimeError):
         _fail_open(key)
         return None
@@ -525,21 +651,18 @@ def pre_tool_call(
         if not isinstance(old_string, str) or not isinstance(new_string, str):
             return None
         previous = _read_previous(path_text, root)
+        if previous == "" and old_string:
+            return _check_text_change(key, path_text, new_string, root)
         if previous is None or old_string not in previous:
             _fail_open(key)
             return None
         proposed = previous.replace(old_string, new_string) if payload.get("replace_all") else previous.replace(old_string, new_string, 1)
         return _check_text_change(key, path_text, proposed, root)
     if mode == "patch" and isinstance(payload.get("patch"), str):
-        for path_text, added_text in _patch_added_chunks(payload["patch"]):
+        for kind, path_text, hunks in _patch_operations(payload["patch"]):
             if not _path_is_reader_copy(path_text, root):
                 continue
-            findings = _changed_findings(added_text, path_text, set(range(1, len(added_text.splitlines()) + 1)), key)
-            if findings is None:
-                _fail_open(key)
-                continue
-            _warn_if_needed(key, findings)
-            denial = _block_message(findings)
+            denial = _check_patch_operation(key, kind, path_text, hunks, root)
             if denial:
                 return denial
     return None

package/assets/lithermes-plugin/diagnostics.py

@@ -498,15 +498,17 @@ def _motion_runtime_lines() -> list[str]:
     command = PLUGIN_ROOT / "skills" / "lit-typographic-motion" / "bin" / "runtime.mjs"
     if not command.is_file():
         return ["motion Chrome: unavailable", "motion ffmpeg: unavailable", "motion WebGL2 renderer: unavailable",
-                "motion software GL: unknown", "motion pre-warm: missing; run lithermes motion-runtime install"]
+                "motion software GL: unknown", "motion pre-warm: missing; run lithermes motion-runtime install",
+                "motion cover encoder: unavailable"]
     try:
         result = subprocess.run(["node", str(command), "status"], capture_output=True, text=True, timeout=35)
-        if result.returncode == 0 and len(result.stdout.splitlines()) == 5:
+        if result.returncode == 0 and len(result.stdout.splitlines()) == 6:
             return ["motion " + line for line in result.stdout.splitlines()]
     except (OSError, subprocess.TimeoutExpired):
         pass
     return ["motion Chrome: unavailable", "motion ffmpeg: unavailable", "motion WebGL2 renderer: unavailable",
-            "motion software GL: unknown", "motion pre-warm: status failed; run lithermes motion-runtime status"]
+            "motion software GL: unknown", "motion pre-warm: status failed; run lithermes motion-runtime status",
+            "motion cover encoder: unavailable"]
 
 
 def _motion_line_needs_attention(line: str) -> bool: