cowork-flow 1.9.2 → 2.0.0

package/template/.cowork-flow/adapters/qoder/adapter.yaml

@@ -13,7 +13,7 @@ capabilities:
   runtimeContextDispatch: native
   runtimeContextBinding: shim
   runtimeContextCleanup: native
-  editScopeWarning: unsupported
+  editScopeWarning: plugin
 dispatch:
   primitive: subagent
   # Host assets ship as a machine-level plugin; their layout is owned by

package/template/.cowork-flow/scripts/adapters/cli/task_lifecycle_commands.py

@@ -441,7 +441,6 @@ def cmd_complete(args: argparse.Namespace) -> int:
     result = service.complete(
         task_dir,
         execution_context=execution_context,
-        allow_unchecked_specs=bool(getattr(args, "allow_unchecked", False)),
         allow_missing_evidence=bool(
             getattr(args, "allow_missing_evidence", False)
         ),

package/template/.cowork-flow/scripts/adapters/cli/task_parser.py

@@ -95,13 +95,6 @@ def _add_next_output_options(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Validate task context JSONL without changing task state",
     )
-    parser.add_argument(
-        "--allow-unchecked",
-        dest="allow_unchecked",
-        action="store_true",
-        help="With task completion: allow unchecked spec-check commands "
-        "(missing/timeout) and record the exemption in task.json meta",
-    )
     parser.add_argument(
         "--allow-missing-evidence",
         dest="allow_missing_evidence",

package/template/.cowork-flow/scripts/adapters/host/claude_code_policy.py

@@ -4,8 +4,7 @@ workflow hook.
 
 Rendering stays in workflow_state_hook.py; this module owns only the
 claude-code transport specifics — the runtime preamble block and the
-PostToolUse spec-advisory path (stderr + exit 2, shared with codex via the
-neutral helper).
+PostToolUse edit-scope advisory.
 """
 
 from __future__ import annotations
@@ -13,8 +12,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+from adapters.host.edit_scope import edit_scope_warning
 from adapters.host.policy_base import HostPolicy
-from adapters.host.workflow_state_hook import spec_only_post_tool_use
 
 CLAUDE_PREAMBLE = (
     (
@@ -30,7 +29,10 @@ def preamble(root: Path) -> tuple[str, ...]:
 
 
 def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
-    return spec_only_post_tool_use(root, hook_input, POLICY)
+    """PostToolUse transport: the edit-scope advisory rides the standard
+    additionalContext envelope, exit 0 — the edit already happened, so
+    this decorates the result and never blocks it."""
+    return edit_scope_warning(root, hook_input), 0
 
 
 POLICY = HostPolicy(

package/template/.cowork-flow/scripts/adapters/host/codex_policy.py

@@ -3,20 +3,19 @@
 
 Rendering stays in workflow_state_hook.py; this module owns only the codex
 transport specifics — the dispatch-mode preamble (config-driven, the codex
-wrapper surfaces it above every injection) and the probe-based session-start
+wrapper surfaces it above every injection), the probe-based session-start
 detection (codex registers UserPromptSubmit only, so the digest shape derives
-from the session state file probe). PostToolUse reuses the neutral spec-only
-stderr path shared with claude-code.
+from the session state file probe), and the PostToolUse edit-scope advisory.
 """
 
 from __future__ import annotations
 
-import sys
 from pathlib import Path
 from typing import Any
 
+from adapters.host.edit_scope import edit_scope_warning
 from adapters.host.policy_base import HostPolicy
-from adapters.host.workflow_state_hook import _load_common, spec_only_post_tool_use
+from adapters.host.workflow_state_hook import _load_common
 
 
 def codex_dispatch_mode(root: Path) -> str:
@@ -47,7 +46,10 @@ def preamble(root: Path) -> tuple[str, ...]:
 
 
 def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
-    return spec_only_post_tool_use(root, hook_input, POLICY)
+    """PostToolUse transport: the edit-scope advisory rides the standard
+    additionalContext envelope, exit 0. apply_patch payloads carry their
+    paths inside the patch text, which the shared extractor covers."""
+    return edit_scope_warning(root, hook_input), 0
 
 
 POLICY = HostPolicy(

package/template/.cowork-flow/scripts/adapters/host/edit_scope.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Shared edit-phase scope advisory (the PostToolUse short path).
+
+At most one line when an edited file is outside the active task's
+file-scope whitelist; empty string (silent) when in scope, when the task
+is not in a spec-contract state, for subagent sessions, or on any error.
+Hosts differ only in transport: inject.py hosts reach this through their
+policy `post_tool_use` slot, the dsh preset plugin through its own Python
+protocol. The wording is frozen by context-injection.md — never fork it
+per host.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from adapters.host.workflow_state_hook import (
+    STAGE_CONTRACT_STATES,
+    _get_active_task_with_fallback,
+    _session_scope,
+)
+
+_APPLY_PATCH_FILE_RE = re.compile(
+    r"^\*\*\* (?:Update|Add|Delete) File: (.+?)\s*$", re.MULTILINE
+)
+
+
+def extract_edited_paths(tool_input: Any) -> list[str]:
+    """Best-effort edited file paths from a PostToolUse tool_input payload.
+
+    Hosts differ: claude-code, zcode, qoder and opencode pass file_path,
+    while codex's apply_patch carries the paths inside the patch text.
+    Returning every extractable path keeps a multi-file patch from
+    silently skipping the warning; deduplication keeps one edit from
+    checking the same file twice."""
+    if not isinstance(tool_input, dict):
+        return []
+    paths: list[str] = []
+    for key in ("file_path", "filePath", "path"):
+        value = tool_input.get(key)
+        if isinstance(value, str) and value.strip():
+            paths.append(value.strip())
+    for key in ("input", "patch", "patchText"):
+        text = tool_input.get(key)
+        if isinstance(text, str):
+            paths.extend(
+                match.strip() for match in _APPLY_PATCH_FILE_RE.findall(text)
+            )
+    seen: set[str] = set()
+    unique: list[str] = []
+    for path in paths:
+        if path not in seen:
+            seen.add(path)
+            unique.append(path)
+    return unique
+
+
+def edit_scope_warning(
+    root: Path,
+    hook_input: dict[str, Any],
+    *,
+    fallback_for_unbound: bool = False,
+) -> str:
+    """At most one line when the edited file is outside the task's
+    file-scope whitelist. Silence rules: no active in_progress/review
+    task, a subagent session, an in-scope path, an unreadable whitelist,
+    or no extractable path. `fallback_for_unbound` follows the calling
+    host's policy (zcode: true). Never raises — the edit has already
+    happened."""
+    try:
+        task_path, status, _source = _get_active_task_with_fallback(
+            root, hook_input, fallback_for_unbound
+        )
+    except Exception:
+        return ""
+    if not task_path or status not in STAGE_CONTRACT_STATES:
+        return ""
+    if _session_scope(root, hook_input) == "subagent":
+        return ""
+    paths = extract_edited_paths(hook_input.get("tool_input"))
+    if not paths:
+        return ""
+    try:
+        from services.fact_view import file_scope_whitelist, path_in_scope
+
+        whitelist = file_scope_whitelist(root, root / task_path)
+    except Exception:
+        return ""
+    for file_path in paths:
+        # Hosts pass absolute edit paths; whitelist entries are
+        # repo-relative. Same normalization as run_edit_checks took.
+        normalized = file_path.replace("\\", "/").strip()
+        try:
+            normalized = (
+                Path(normalized).resolve().relative_to(root.resolve()).as_posix()
+            )
+        except (ValueError, OSError):
+            pass
+        try:
+            if path_in_scope(whitelist, normalized).get("inScope"):
+                continue
+        except Exception:
+            return ""
+        while normalized.startswith("./"):
+            normalized = normalized[2:]
+        return (
+            f"⚠️ {normalized} is outside the task's declared scope. "
+            "If intended, declare it in the task's `implement.jsonl` (agent-mutable) "
+            "or revert the edit."
+        )
+    return ""

package/template/.cowork-flow/scripts/adapters/host/opencode_policy.py

@@ -12,6 +12,10 @@ session file probe (session_start_event=None), as with codex.
 
 from __future__ import annotations
 
+from pathlib import Path
+from typing import Any
+
+from adapters.host.edit_scope import edit_scope_warning
 from adapters.host.policy_base import HostPolicy
 
 OPENCODE_DIGEST_POLICY = (
@@ -20,6 +24,13 @@ OPENCODE_DIGEST_POLICY = (
 )
 
 
+def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
+    """PostToolUse transport for the plugin's tool.execute.after hook: the
+    edit-scope advisory is bare text (emit_text), appended to the finished
+    tool output by the shim. Exit 0 — never blocks the edit."""
+    return edit_scope_warning(root, hook_input), 0
+
+
 POLICY = HostPolicy(
     host="opencode",
     digest_policy=OPENCODE_DIGEST_POLICY,
@@ -29,4 +40,5 @@ POLICY = HostPolicy(
     emit_not_initialized=True,
     # stdout is the injection itself: the shim forwards it verbatim.
     emit_text=True,
+    post_tool_use=post_tool_use,
 )

package/template/.cowork-flow/scripts/adapters/host/qoder_policy.py

@@ -3,9 +3,7 @@
 
 Rendering stays in workflow_state_hook.py; this module owns only what Qoder
 changes. Qoder shares the JSON envelope shape (`hookSpecificOutput`) with
-claude-code and codex, but its `PostToolUse` is not a blockable event: exit 2
-there is ignored, so the edit-phase spec advisory must travel as
-`additionalContext` on exit 0 instead of stderr.
+claude-code and codex.
 
 Host assets (hooks declaration, fixed subagents, commands, skills) ship as a
 machine-level Qoder plugin, so the hook reaches this entry through the plugin
@@ -17,8 +15,9 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+from adapters.host.edit_scope import edit_scope_warning
 from adapters.host.policy_base import HostPolicy
-from adapters.host.workflow_state_hook import hook_state_summary, spec_edit_warning
+from adapters.host.workflow_state_hook import hook_state_summary
 
 QODER_PREAMBLE = (
     (
@@ -34,7 +33,10 @@ def preamble(root: Path) -> tuple[str, ...]:
 
 
 def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
-    return spec_edit_warning(root, hook_input, POLICY), 0
+    """PostToolUse transport: the edit-scope advisory rides the standard
+    additionalContext envelope, exit 0 (never a systemMessage — that gate
+    stays on the two injecting events)."""
+    return edit_scope_warning(root, hook_input), 0
 
 
 # The task directory name is user-chosen and unbounded, and the host renders

package/template/.cowork-flow/scripts/adapters/host/workflow_state_hook.py

@@ -466,97 +466,6 @@ def _stage_contract_block(
         return None
 
 
-_APPLY_PATCH_FILE_RE = re.compile(
-    r"^\*\*\* (?:Update|Add|Delete) File: (.+?)\s*$", re.MULTILINE
-)
-
-
-def _extract_edited_paths(tool_input: Any) -> list[str]:
-    """Best-effort edited file paths from a PostToolUse tool_input payload.
-
-    Hosts differ: claude-code and zcode pass file_path, while codex's
-    apply_patch carries the paths inside the patch text. Returning every
-    extractable path keeps a multi-file patch from silently skipping
-    checks; deduplication keeps one edit from burning the throttle window
-    on the same file twice."""
-    if not isinstance(tool_input, dict):
-        return []
-    paths: list[str] = []
-    for key in ("file_path", "filePath", "path"):
-        value = tool_input.get(key)
-        if isinstance(value, str) and value.strip():
-            paths.append(value.strip())
-    for key in ("input", "patch", "patchText"):
-        text = tool_input.get(key)
-        if isinstance(text, str):
-            paths.extend(
-                match.strip() for match in _APPLY_PATCH_FILE_RE.findall(text)
-            )
-    seen: set[str] = set()
-    unique: list[str] = []
-    for path in paths:
-        if path not in seen:
-            seen.add(path)
-            unique.append(path)
-    return unique
-
-
-def spec_edit_warning(
-    root: Path,
-    hook_input: dict[str, Any],
-    policy: HostPolicy,
-) -> str:
-    """Editor-phase spec-check single-line warning (PostToolUse short path).
-
-    Delegated subagents are the primary coders, so spec violations must
-    reach them too: only an active in_progress/review task is required —
-    session scope is not consulted here (scope warnings stay main-only in
-    the zcode policy's edit_scope_warning). Hosts with
-    fallback_for_unbound (zcode) follow another main session's binding for
-    their never-bound hook sessions only while exactly one main-session
-    binding exists (see _get_active_task_with_fallback); strict-identity
-    hosts (claude-code/codex) require the calling session's own binding.
-    no_task, planning, and completed stay silent. Empty string means
-    silent. Never raises — the editor path must not break edits.
-    """
-    try:
-        task_path, status, _source = _get_active_task_with_fallback(
-            root, hook_input, policy.fallback_for_unbound
-        )
-    except Exception:
-        return ""
-    if not task_path or status not in STAGE_CONTRACT_STATES:
-        return ""
-    paths = _extract_edited_paths(hook_input.get("tool_input"))
-    if not paths:
-        return ""
-    try:
-        from services.spec_check import run_edit_checks
-
-        for path in paths:
-            warning = run_edit_checks(root, path)
-            if warning:
-                return warning
-        return ""
-    except Exception:
-        return ""
-
-
-def spec_only_post_tool_use(
-    root: Path,
-    hook_input: dict[str, Any],
-    policy: HostPolicy,
-) -> tuple[str, int]:
-    """claude-code / codex PostToolUse transport: spec-check advisory on
-    stderr only (exit 2 surfaces it to the model); the edit itself has
-    already happened. No additionalContext payload."""
-    warning = spec_edit_warning(root, hook_input, policy)
-    if warning:
-        print(warning, file=sys.stderr)
-        return "", 2
-    return "", 0
-
-
 def _load_breadcrumbs(root: Path) -> dict[str, str]:
     path = (
         root

package/template/.cowork-flow/scripts/adapters/host/zcode_policy.py

@@ -4,27 +4,20 @@
 Rendering stays in workflow_state_hook.py (single source shared with the
 other hosts); this module owns only what is zcode-specific — the digest
 policy wording, the newest-session fallback for unbound hook sessions, the
-rebind hints and essential-files check ported from the zcode JS hook, the
-merged scope+spec edit warning, and the PostToolUse transport contract the
-zcode shim relies on.
+rebind hints and essential-files check ported from the zcode JS hook, and
+the PostToolUse transport contract the zcode shim relies on.
 """
 
 from __future__ import annotations
 
 import json
 import re
-import sys
 from pathlib import Path
 from typing import Any
 
+from adapters.host.edit_scope import edit_scope_warning
 from adapters.host.policy_base import HostPolicy
-from adapters.host.workflow_state_hook import (
-    STAGE_CONTRACT_STATES,
-    _get_active_task_with_fallback,
-    _session_scope,
-    build_hook_context,
-    spec_edit_warning,
-)
+from adapters.host.workflow_state_hook import build_hook_context
 
 # Wording frozen by context-injection.md: zcode drops the
 # registry warning and asks for the fingerprint every hook.
@@ -162,72 +155,12 @@ def essential_files_warning(root: Path) -> str:
     )
 
 
-def edit_scope_warning(root: Path, hook_input: dict[str, Any]) -> str:
-    """Per-edit out-of-scope warning (zcode-only capability). Port of the
-    zcode hook's editScopeWarning: at most one line when the edited file is
-    outside the task's file-scope whitelist. Silence rules match the JS
-    source, including the newest-session display fallback for sessions with
-    no resolvable identity. Never raises."""
-    try:
-        task_path, status, _source = _get_active_task_with_fallback(
-            root, hook_input, POLICY.fallback_for_unbound
-        )
-    except Exception:
-        return ""
-    if not task_path or status not in STAGE_CONTRACT_STATES:
-        return ""
-    if _session_scope(root, hook_input) == "subagent":
-        return ""
-    tool_input = hook_input.get("tool_input")
-    file_path = (
-        tool_input.get("file_path") if isinstance(tool_input, dict) else None
-    )
-    if not isinstance(file_path, str) or not file_path.strip():
-        return ""
-    # Hosts pass absolute edit paths; whitelist entries are
-    # repo-relative. Same normalization as run_edit_checks.
-    normalized = file_path.replace("\\", "/").strip()
-    try:
-        normalized = (
-            Path(normalized).resolve().relative_to(root.resolve()).as_posix()
-        )
-    except (ValueError, OSError):
-        pass
-    try:
-        from services.fact_view import file_scope_whitelist, path_in_scope
-
-        whitelist = file_scope_whitelist(root, root / task_path)
-        if path_in_scope(whitelist, normalized).get("inScope"):
-            return ""
-    except Exception:
-        return ""
-    while normalized.startswith("./"):
-        normalized = normalized[2:]
-    return (
-        f"⚠️ {normalized} is outside the task's declared scope. "
-        "If intended, add it with `task context add` (agent-mutable) "
-        "or revert the edit."
-    )
-
-
-def merged_edit_warning(root: Path, hook_input: dict[str, Any]) -> str:
-    """zcode PostToolUse Edit/Write/MultiEdit context: the scope warning and
-    the spec-check warning merged into one additionalContext payload, at
-    most one line each, joined by a newline (port of the zcode hook's
-    mergedEditWarning)."""
-    scope_line = edit_scope_warning(root, hook_input)
-    spec_line = spec_edit_warning(root, hook_input, POLICY)
-    if scope_line and spec_line:
-        return f"{scope_line}\n{spec_line}"
-    return scope_line or spec_line
-
-
 def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
-    """zcode PostToolUse transport: Edit/Write/MultiEdit get the merged
-    edit warning; Bash events refresh the full state only for workflow
-    lifecycle commands (the shim pre-filters the common case, this keeps
-    the entry correct standalone). Edit storms must not multiply the
-    injection payload."""
+    """zcode PostToolUse transport: Edit/Write/MultiEdit get the shared
+    scope warning (with zcode's newest-session fallback); Bash events
+    refresh the full state only for workflow lifecycle commands (the shim
+    pre-filters the common case, this keeps the entry correct standalone).
+    Edit storms must not multiply the injection payload."""
     tool_name = str(hook_input.get("tool_name") or "")
     tool_input = hook_input.get("tool_input")
     file_path = (
@@ -238,7 +171,12 @@ def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
         and isinstance(file_path, str)
         and file_path.strip()
     ):
-        return merged_edit_warning(root, hook_input), 0
+        return (
+            edit_scope_warning(
+                root, hook_input, fallback_for_unbound=POLICY.fallback_for_unbound
+            ),
+            0,
+        )
     if not is_lifecycle_bash(hook_input):
         return "", 0
     claim_after_lifecycle_bash(root, hook_input)

package/template/.cowork-flow/scripts/run.py

@@ -32,7 +32,6 @@ COMMAND_SCRIPTS = {
     "state": "adapters/cli/state.py",
     "mcp-state": "adapters/mcp/state_server.py",
     "subagent": "adapters/cli/subagent.py",
-    "spec-check": "adapters/cli/spec_check.py",
 }
 RESERVED_COMMAND_NAMES = (*COMMAND_SCRIPTS, "python", "help", "-h", "--help")
 
@@ -51,7 +50,6 @@ Common commands:
   resume
   task
   state
-  spec-check
   get-context
   get-developer
   init-developer

package/template/.cowork-flow/scripts/services/context_paths.py

@@ -24,10 +24,10 @@ DEFAULT_SCOPE_RULES: dict = {
         "trailingSlashRejectedTypes": ["planned-file", "deleted-file"],
     },
     "stageContract": {
-        "budget": 1200,
+        "budget": 3400,
         "scopeLimit": 8,
         "specLimit": 4,
-        "verifyLimit": 3,
+        "verifyLimit": 10,
     },
 }
 

package/template/.cowork-flow/scripts/services/fact_view.py

@@ -19,7 +19,7 @@ from typing import Any
 
 GOAL_TRUNCATE = 300
 VERIFY_COMMAND_TRUNCATE = 120
-VERIFY_COMMAND_MAX = 5
+VERIFY_COMMAND_MAX = 10
 SCOPE_BOUNDARY_TRUNCATE = 160
 ANCHOR_SECTIONS = ("目标", "验收标准", "被拒方案", "验证命令", "范围边界")
 ACCEPTANCE_RE = re.compile(
@@ -225,12 +225,12 @@ def spec_entries_for_task(
 
 STAGE_CONTRACT_SCOPE_LIMIT = 8
 STAGE_CONTRACT_SPECS_LIMIT = 4
-STAGE_CONTRACT_VERIFY_LIMIT = 3
-STAGE_CONTRACT_BUDGET = 1200
+STAGE_CONTRACT_VERIFY_LIMIT = 10
+STAGE_CONTRACT_BUDGET = 3400
 GATES_TEXT = (
     "Gates: edits outside Scope are review blockers; CLAUDE.md and workflow "
     "files are protected; spec/ edits may be allowed by review policy; "
-    "scope is agent-mutable (self-declared via task context add)"
+    "scope is agent-mutable (declare more in implement.jsonl)"
 )
 # Delegated subtasks render the parent scope as a read-only
 # reference: a child must not believe it can self-declare
@@ -257,11 +257,14 @@ def _fit_stage_contract(
     budget: int = STAGE_CONTRACT_BUDGET,
 ) -> list[str]:
     """Degrade an over-budget block without ever emitting a malformed one:
-    the closing tag and the guard rows (Scope/Gates) always survive. Order:
-    1) drop removable rows (Specs/Verify) from the tail; 2) shrink Scope
-    entries one by one (min 1); 3) last-resort codepoint cut that keeps the
-    closing tag. Single renderer: the host shims transport this output
-    unchanged, so the row-role rules and the drop order live here only."""
+    the opening tag, the closing tag and the guard rows (Scope/Gates) always
+    survive intact. Order: 1) drop removable rows (Specs/Verify) from the
+    tail; 2) shrink Scope entries one by one (min 1); 3) `_cut_scope_rows`
+    shortens the Scope rows' own text, and nothing else -- it returns None
+    when even that cannot keep the block usable, and the block is then
+    returned as is, over budget (guards and parseability outrank it).
+    Single renderer: the host shims transport this output unchanged, so the
+    row-role rules and the drop order live here only."""
     if len("\n".join(lines)) <= budget:
         return lines
     removable = [
@@ -289,18 +292,43 @@ def _fit_stage_contract(
         lines = candidate
     if len("\n".join(lines)) <= budget:
         return lines
-    closing = lines[-1]
-    # The final join inserts one newline between the cut body
-    # and the closing tag; reserve it so the block stays
-    # within budget byte-for-byte.
-    room = budget - len(closing) - 1
-    body = "\n".join(lines[:-1])
-    if len(body) <= room:
-        return lines
-    head = body[:room].rstrip()
-    if not head:
-        return lines
-    return [head, closing]
+    cut = _cut_scope_rows(lines, budget)
+    return lines if cut is None else cut
+
+
+def _cut_scope_rows(lines: list[str], budget: int) -> list[str] | None:
+    """Last resort: shorten the text of every Scope row so the block fits.
+
+    Returns None -- the caller then returns the block whole and lets it
+    exceed the budget -- in three cases: there is no Scope row to cut at all
+    (a shape the renderer never emits), the fixed rows plus a minimal
+    `Scope: X` row do not fit, or the cut would shave a `Scope: ` label off a
+    row (`rstrip` landing inside the entry's leading whitespace). A body-wide
+    cut is never allowed: it would truncate the tag every consumer matches
+    on, and a label-less row counts as a dropped guard row. The floor is not
+    redundant with the label check -- a negative `room` slices from the row's
+    tail, so without it a long row would go through chopped and still over
+    budget. Guard rows and parseability outrank the budget.
+    """
+    fixed = [line for line in lines if not line.startswith("Scope:")]
+    scope_count = len(lines) - len(fixed)
+    if scope_count == 0:
+        return None
+    # Every Scope row is shortened to the same width, so the room left after
+    # the fixed rows and the separators is shared between them.
+    room = (budget - len("\n".join(fixed)) - scope_count) // scope_count
+    if room < len("Scope: ") + 1:
+        return None
+    cut = [
+        line[:room].rstrip() if line.startswith("Scope:") else line
+        for line in lines
+    ]
+    if any(
+        original.startswith("Scope:") and not shortened.startswith("Scope: ")
+        for original, shortened in zip(lines, cut)
+    ):
+        return None
+    return cut
 
 
 def _stage_contract_lines(