cowork-flow 1.2.0 → 1.4.0

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

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""zcode host policy: the zcode-specific behaviors of the workflow hook.
+
+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.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from adapters.host.workflow_state_hook import HostPolicy
+
+# Digest policy wording frozen by context-injection.md (zcode drops the
+# registry-warning line and asks for the fingerprint on every hook).
+ZCODE_DIGEST_POLICY = (
+    "policy: repeat fingerprint every hook; "
+    "read full spec files only before listed actions."
+)
+
+# The zcode shim (hooks/inject-context.js) pre-filters Bash events with the
+# same rule; this entry keeps the transport contract correct standalone.
+LIFECYCLE_BASH_RE = re.compile(r"\brun(?:\.cmd)?\s+(?:task|subagent|resume)\b")
+
+# Port of the zcode hook's essential-files check (inject-context.js
+# checkEssentialFiles): appended to the zcode context when any guard file of
+# the workflow install is missing.
+ESSENTIAL_FILES = (
+    "AGENTS.md",
+    ".cowork-flow/config.yaml",
+    ".cowork-flow/run",
+    ".cowork-flow/spec/runtime/contract-registry.json",
+    ".cowork-flow/spec/contracts/workflow-state-templates.md",
+)
+
+
+def is_lifecycle_bash(hook_input: dict[str, Any]) -> bool:
+    tool_input = hook_input.get("tool_input")
+    command = (
+        tool_input.get("command") if isinstance(tool_input, dict) else None
+    )
+    if not isinstance(command, str):
+        return False
+    normalized = command.replace("\\", "/")
+    return ".cowork-flow/run" in normalized or bool(
+        LIFECYCLE_BASH_RE.search(normalized)
+    )
+
+
+# Activation intent inside a lifecycle Bash command: `task next <dir> --run`,
+# `task start <dir>`, `resume <dir>` (the run prefix is optional). Query
+# forms (`task next --json`, `task next --run` without a dir) match nothing
+# claimable — the captured token must be a task dir whose task.json exists.
+ACTIVATION_COMMAND_RE = re.compile(
+    r"\btask\s+next\s+(?P<next>\S+)\s+--run\b"
+    r"|\btask\s+start\s+(?P<start>\S+?)(?=\s|$)"
+    r"|(?<![\w./-])resume\s+(?P<resume>\S+?)(?=\s|$)"
+)
+
+
+def _resolvable_task_path(root: Path, token: str) -> str | None:
+    candidates = [token]
+    if not token.startswith(".cowork-flow/"):
+        candidates.append(f".cowork-flow/tasks/{token}")
+    for candidate in candidates:
+        normalized = candidate.replace("\\", "/").strip("/")
+        if (root / normalized / "task.json").is_file():
+            return normalized
+    return None
+
+
+def claim_after_lifecycle_bash(root: Path, hook_input: dict[str, Any]) -> None:
+    """Bind the activated task to this hook session's own identity.
+
+    The lifecycle Bash CLI resolves a process-fallback identity, so the
+    binding it writes is shared across windows; PostToolUse re-binds with the
+    hook input's session id via session_state.claim_active_task (explicit /
+    host_session provenance only). Commands without an activation intent or
+    with an unresolvable task dir claim nothing, and claim failure stays
+    silent — the refresh path below still renders the state."""
+    tool_input = hook_input.get("tool_input")
+    command = (
+        tool_input.get("command") if isinstance(tool_input, dict) else None
+    )
+    if not isinstance(command, str):
+        return
+    match = ACTIVATION_COMMAND_RE.search(command.replace("\\", "/"))
+    if match is None:
+        return
+    token = next(value for value in match.groupdict().values() if value)
+    if token.startswith("-"):
+        return
+    task_path = _resolvable_task_path(root, token)
+    if task_path is None:
+        return
+    try:
+        from runtime.session_state import claim_active_task
+
+        claim_active_task(root, task_path, hook_input)
+    except Exception:
+        pass
+
+
+def zcode_session_alias(data: dict[str, Any]) -> dict[str, Any]:
+    # Ported from the zcode hook's resolveSessionKey candidate order
+    # (env wins inside session_state; input aliases only fill the gap).
+    # Without this, a bare sessionId/session_id would resolve as a codex
+    # session and lose the session's own binding.
+    existing = data.get("zcode_session_id")
+    if isinstance(existing, str) and existing.strip():
+        return data
+    for key in ("ZCODE_SESSION_ID", "sessionId", "session_id"):
+        value = data.get(key)
+        if isinstance(value, str) and value.strip():
+            data["zcode_session_id"] = value
+            break
+    return data
+
+
+def rebind_hints(root: Path) -> str:
+    """Port of the zcode hook's formatRebindHints: one-level task scan for
+    bindable (non-completed) tasks, appended to no_task/missing bodies."""
+    tasks_dir = root / ".cowork-flow" / "tasks"
+    try:
+        children = sorted(tasks_dir.iterdir())
+    except OSError:
+        return ""
+    entries: list[str] = []
+    for child in children:
+        if not child.is_dir():
+            continue
+        relative = f".cowork-flow/tasks/{child.name}"
+        task_json = child / "task.json"
+        if not task_json.is_file():
+            continue
+        try:
+            data = json.loads(task_json.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, ValueError):
+            status = "unknown"
+        else:
+            status = str(data.get("status") or "unknown").strip() or "unknown"
+        if status == "completed":
+            continue
+        entries.append(f"- {relative} ({status})")
+    if not entries:
+        return ""
+    return (
+        "\n活动任务（可用 ./.cowork-flow/run task next <dir> 改绑）：\n"
+        + "\n".join(entries)
+    )
+
+
+def essential_files_warning(root: Path) -> str:
+    missing = [rel for rel in ESSENTIAL_FILES if not (root / rel).exists()]
+    if not missing:
+        return ""
+    return (
+        "\n\n⚠️ 缺少必要文件："
+        + ", ".join(missing)
+        + "。\n请立即创建这些文件以保障工作流正常运行。"
+    )
+
+
+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."""
+    from adapters.host.workflow_state_hook import (
+        STAGE_CONTRACT_STATES,
+        _get_active_task_with_fallback,
+        _session_scope,
+    )
+
+    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 the spec path applies in 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)."""
+    from adapters.host.workflow_state_hook import spec_edit_warning
+
+    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."""
+    tool_name = str(hook_input.get("tool_name") or "")
+    tool_input = hook_input.get("tool_input")
+    file_path = (
+        tool_input.get("file_path") if isinstance(tool_input, dict) else None
+    )
+    if (
+        tool_name in {"Edit", "Write", "MultiEdit"}
+        and isinstance(file_path, str)
+        and file_path.strip()
+    ):
+        return merged_edit_warning(root, hook_input), 0
+    if not is_lifecycle_bash(hook_input):
+        return "", 0
+    claim_after_lifecycle_bash(root, hook_input)
+    from adapters.host.workflow_state_hook import build_hook_context
+
+    context = build_hook_context(
+        root,
+        hook_input,
+        host=POLICY.host,
+        adapter="zcode.plugin",
+        preamble=(),
+        session_start=False,
+        policy=POLICY,
+    )
+    return context, 0
+
+
+POLICY = HostPolicy(
+    host="zcode",
+    digest_policy=ZCODE_DIGEST_POLICY,
+    digest_warning_silent=True,
+    session_alias=zcode_session_alias,
+    rebind_hints=rebind_hints,
+    essential_files_warning=essential_files_warning,
+    fallback_for_unbound=True,
+    post_tool_use=post_tool_use,
+    emit_indent=True,
+    emit_not_initialized=True,
+)

package/template/.cowork-flow/scripts/adapters/mcp/state_server.py

@@ -99,16 +99,36 @@ TOOLS = [
 ]
 
 
-def _tool_task_state(root: Path, arguments: dict) -> dict:
+TRUSTED_PROVENANCE = ("explicit", "host_session")
+
+
+def _implicit_active_task(root: Path) -> tuple[str | None, str]:
+    """Implicit resolution (no explicit `task` argument): the caller's own
+    session-bound active task. A process-fallback identity is shared across
+    every window on the host and a missing identity is no identity at all —
+    neither may impersonate "the current task", so both return no task with
+    an identity-untrusted reason. Returns (task_path, no_task_reason)."""
     from runtime.session_state import get_active_task
+
+    active = get_active_task(root)
+    if active.provenance not in TRUSTED_PROVENANCE:
+        return None, (
+            f"no-active-task (identity-untrusted: {active.provenance})"
+        )
+    if not active.task_path:
+        return None, "no-active-task"
+    return active.task_path, "no-active-task"
+
+
+def _tool_task_state(root: Path, arguments: dict) -> dict:
     from services.fact_view import build_fact_view
     from services.task_repository import TaskRepository, TaskRepositoryError
 
     target = arguments.get("task")
     if not target:
-        target = get_active_task(root).task_path
+        target, reason = _implicit_active_task(root)
         if not target:
-            return {"schemaVersion": 1, "task": None, "reason": "no-active-task"}
+            return {"schemaVersion": 1, "task": None, "reason": reason}
     try:
         task_dir = TaskRepository(root).resolve(target)
     except TaskRepositoryError as error:
@@ -124,17 +144,23 @@ def _tool_task_list(root: Path, _arguments: dict) -> dict:
     records, error = _list_task_records(root, mine=False, status=None)
     if error:
         return {"tasks": [], "count": 0, "error": error}
+    # records[].active is a per-session fact: only a trusted caller identity
+    # whose bound path matches the record may carry it.
+    trusted_active = _implicit_active_task(root)[0]
+    for record in records:
+        record["active"] = (
+            bool(trusted_active) and record.get("path") == trusted_active
+        )
     return {"tasks": records, "count": len(records)}
 
 
 def _resolve_task_dir(root: Path, target: str | None) -> Path:
-    from runtime.session_state import get_active_task
     from services.task_repository import TaskRepository, TaskRepositoryError
 
     if not target:
-        target = get_active_task(root).task_path
+        target, reason = _implicit_active_task(root)
         if not target:
-            raise ValueError("no-active-task")
+            raise ValueError(reason)
     try:
         task_dir = TaskRepository(root).resolve(target)
     except TaskRepositoryError as error:
@@ -166,13 +192,10 @@ def _tool_task_scope(root: Path, arguments: dict) -> dict:
 
 
 def _tool_task_specs(root: Path, arguments: dict) -> dict:
-    from services.context_discovery import implement_spec_entries
-    from services.fact_view import _read_json
+    from services.fact_view import spec_entries_for_task
 
     task_dir = _resolve_task_dir(root, arguments.get("task"))
-    task = _read_json(task_dir / "task.json")
-    dev_type = task.get("dev_type") if isinstance(task, dict) else None
-    specs = implement_spec_entries(root, dev_type)
+    dev_type, specs = spec_entries_for_task(root, task_dir)
     return {
         "taskDir": task_dir.name,
         "devType": dev_type,

package/template/.cowork-flow/scripts/runtime/session_state.py

@@ -34,6 +34,14 @@ RUNTIME_CONTEXT_PROMPT_RE = re.compile(
 HOST_CONTEXT_PROMPT_RE = re.compile(
     r"(?im)^\s*cowork_host_context_key\s*:\s*([A-Za-z0-9._-]+)\s*$"
 )
+# Process-label providers: hosts whose Bash spawns carry only a shared
+# process label (no per-session id). Data-driven like the env mapping tables
+# below — adding a host is one row, no host branches in this module. The
+# identity is process-level shared; consumers must treat it as
+# PROVENANCE_PROCESS_FALLBACK and degrade accordingly.
+PROCESS_LABEL_PROVIDERS: tuple[tuple[str, str], ...] = (
+    ("zcode", "ZCODE_PROCESS_LABEL"),
+)
 
 
 @dataclass(frozen=True)
@@ -76,15 +84,17 @@ def resolve_context_key_with_provenance(
     context_key = _resolve_input_context_key(values)
     if context_key:
         return context_key, PROVENANCE_HOST_SESSION
-    # zcode 主会话（Bash CLI）无任何 host session id：用进程标签兜底，
-    # 保证 task start / session 解析一次成功，不再回落到其它 host。
-    # 该身份是进程级共享的，消费方必须按 PROVENANCE_PROCESS_FALLBACK 降级处理。
-    process_label = os.environ.get("ZCODE_PROCESS_LABEL")
-    if process_label and process_label.strip():
-        return (
-            _prefixed_context_key("zcode", process_label),
-            PROVENANCE_PROCESS_FALLBACK,
-        )
+    # Hosts whose Bash CLI carries no session id fall back to their shared
+    # process label so task start / session resolution succeeds once instead
+    # of dropping to another host's identity. Process-level shared identity —
+    # consumers must degrade per PROVENANCE_PROCESS_FALLBACK.
+    for prefix, env_name in PROCESS_LABEL_PROVIDERS:
+        process_label = os.environ.get(env_name)
+        if process_label and process_label.strip():
+            return (
+                _prefixed_context_key(prefix, process_label),
+                PROVENANCE_PROCESS_FALLBACK,
+            )
     return None, PROVENANCE_MISSING
 
 
@@ -320,6 +330,41 @@ def set_active_task(repo_root: Path, task_path: str) -> ActiveTask | None:
     return active
 
 
+def claim_active_task(
+    repo_root: Path,
+    task_path: str,
+    values: Mapping[str, object] | None = None,
+) -> ActiveTask | None:
+    """Bind the task to the caller's own resolved session identity.
+
+    Used by host PostToolUse hooks after a lifecycle Bash activation: the CLI
+    process often only carries a shared process-fallback identity, so the hook
+    re-binds with the session id parsed from the hook input. Only explicit /
+    host_session provenance may claim — process_fallback and missing
+    identities are shared or absent, and a main binding written with them
+    would hijack the binding for every other window. Claim failures return
+    None and write nothing.
+    """
+    context_key, provenance = resolve_context_key_with_provenance(values)
+    if not context_key or provenance not in (
+        PROVENANCE_EXPLICIT,
+        PROVENANCE_HOST_SESSION,
+    ):
+        return None
+    normalized = task_path.replace("\\", "/")
+    target = repo_root / normalized
+    if not target.is_dir():
+        return None
+    data: dict[str, object] = {
+        FIELD_ACTIVE_TASK_PATH: normalized,
+        FIELD_SCOPE: SCOPE_MAIN,
+        "platform": platform_from_context_key(context_key),
+        "last_seen_at": _now(),
+    }
+    _write_json(_session_path(repo_root, context_key), data)
+    return ActiveTask(normalized, context_key, "session", provenance=provenance)
+
+
 def get_active_task(repo_root: Path, values: Mapping[str, object] | None = None) -> ActiveTask:
     context_key, provenance = resolve_context_key_with_provenance(values)
     if not context_key:

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

@@ -85,14 +85,27 @@ def detect_installed_platforms(repo_root: Path | None = None) -> list[str]:
     return platforms
 
 
-def use_claude_skill_context(repo_root: Path | None = None) -> bool:
-    return detect_installed_platforms(repo_root) == ["claude-code"]
+# Platforms that load skills from their own asset dir declare it here; the
+# shared .agents/skills layout is the default for every other platform.
+SKILL_REPLICA_DIR_BY_PLATFORM = {
+    "claude-code": ".claude/skills",
+}
+
+
+def skill_root(repo_root: Path | None = None) -> str:
+    """Neutral rule over platform data: when exactly one platform is
+    installed and that platform declares a dedicated skill replica dir, the
+    skills live there; otherwise the shared .agents/skills layout applies."""
+    platforms = detect_installed_platforms(repo_root)
+    if len(platforms) == 1:
+        dedicated = SKILL_REPLICA_DIR_BY_PLATFORM.get(platforms[0])
+        if dedicated:
+            return dedicated
+    return f"{DIR_AGENTS}/skills"
 
 
 def skill_path(name: str, repo_root: Path | None = None) -> str:
-    if use_claude_skill_context(repo_root):
-        return f".claude/skills/{name}/SKILL.md"
-    return f"{DIR_AGENTS}/skills/{name}/SKILL.md"
+    return f"{skill_root(repo_root)}/{name}/SKILL.md"
 
 
 def get_domain_skill_context(

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

@@ -189,6 +189,20 @@ def path_in_scope(
     }
 
 
+def spec_entries_for_task(
+    repo_root: Path, task_dir: Path
+) -> tuple[Any, list[dict]]:
+    """Public facade for the implement reading list: the task's dev_type plus
+    the dispatched spec/skill entries. The MCP task_specs tool and the
+    `task specs` CLI fact command both consume this, so the two channels
+    cannot drift."""
+    from services.context_discovery import implement_spec_entries
+
+    task = _read_json(task_dir / "task.json")
+    dev_type = task.get("dev_type") if isinstance(task, dict) else None
+    return dev_type, implement_spec_entries(repo_root, dev_type)
+
+
 STAGE_CONTRACT_STATES = ("in_progress", "review")
 STAGE_CONTRACT_SCOPE_LIMIT = 8
 STAGE_CONTRACT_SPECS_LIMIT = 4

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

@@ -33,10 +33,11 @@ from typing import Iterable
 # is kept free of CLI/process plumbing concerns by architecture tests.
 IS_WINDOWS = os.name == "nt"
 
-# Editor-phase budget: the zcode/claude PostToolUse hook runs on a 5s hard
-# budget including interpreter startup, so edit-phase commands get 3s and
-# nothing more.
-EDIT_PHASE_TIMEOUT = 3.0
+# Editor-phase budget: the zcode/claude PostToolUse hook runs on a ~5s hard
+# budget including interpreter startup, so edit-phase commands get 2.5s —
+# leaving room for Python startup plus cmd.exe wrapper overhead on slow
+# machines. Slow or unfiltered commands belong to the lifecycle phase.
+EDIT_PHASE_TIMEOUT = 2.5
 DEFAULT_TIMEOUT = 30.0
 MAX_TIMEOUT = 120.0
 MAX_FIRST_LINE_CHARS = 200
@@ -215,7 +216,7 @@ def _parse_files(raw: str) -> tuple[tuple[str, ...], list[str]]:
     errors: list[str] = []
     matched: list[str] = []
     for part in raw.split(","):
-        token = part.strip().replace("\\", "/")
+        token = _strip_quotes(part).replace("\\", "/")
         while token.startswith("./"):
             token = token[2:]
         if not token:
@@ -287,12 +288,24 @@ def _first_violation_line(output: Iterable[str]) -> str:
 def _run_command(decl: CheckDecl, repo_root: Path) -> tuple[str, int | None, str, list[str]]:
     """Execute one declaration. Returns (status, exit_code, reason, output)."""
     command = _decl_for_platform(decl)
+    tokens: list[str] = []
     if IS_WINDOWS:
         # Windows: newer runtimes refuse to spawn .cmd shims directly
-        # (EINVAL); route through cmd.exe the way npm shims launch. Failure
-        # to find cmd.exe or the entry degrades to unchecked, never pass.
-        argv = ["cmd.exe", "/c", command]
-        popen_kwargs: dict = {}
+        # (EINVAL), so the command goes through cmd.exe. Passing an argv list
+        # makes list2cmdline escape an already-quoted command into `\"...\"`
+        # — cmd then strips the outer quotes and fails to parse — so the
+        # raw string runs via shell=True, exactly the way npm shims launch.
+        # The entry check keeps "missing command" as unchecked instead of a
+        # cmd.exe rc=1 masquerading as a violation.
+        try:
+            tokens = shlex.split(command, posix=False)
+        except ValueError:
+            tokens = []
+        first_token = tokens[0].strip('"') if tokens else ""
+        if not first_token or shutil.which(first_token) is None:
+            return "unchecked", None, f"command not found: {first_token}", []
+        argv: str | list[str] = command
+        popen_kwargs: dict = {"shell": True}
     else:
         try:
             argv = shlex.split(command)
@@ -309,7 +322,11 @@ def _run_command(decl: CheckDecl, repo_root: Path) -> tuple[str, int | None, str
             argv,
             cwd=str(repo_root),
             capture_output=True,
-            text=True,
+            # Explicit UTF-8 with replacement: command output is process
+            # noise (first violation line only), never allowed to crash the
+            # reader thread or masquerade as a check outcome.
+            encoding="utf-8",
+            errors="replace",
             timeout=decl.timeout,
             check=False,
             **popen_kwargs,
@@ -418,7 +435,9 @@ def normalized_one_line(report: dict) -> str:
 # Per-file throttle for editor-phase runs: an edit storm must not multiply
 # the command cost. State lives in the workflow runtime directory because
 # every hook invocation is a fresh process — in-memory maps cannot throttle
-# across invocations.
+# across invocations. The slot is recorded only after a completed run: an
+# executor crash must not consume the interval, so the next edit within it
+# still runs its checks.
 EDIT_THROTTLE_INTERVAL_SECONDS = 10.0
 EDIT_THROTTLE_FILE = ".cowork-flow" / Path(".runtime") / "spec-edit-throttle.json"
 
@@ -481,11 +500,14 @@ def run_edit_checks(
             and current - state["ts"] < EDIT_THROTTLE_INTERVAL_SECONDS
         ):
             return ""
-        _write_throttle(repo_root, normalized, current)
     try:
         report = run_checks(repo_root, phase="edit", changed_files=[normalized])
     except Exception:
+        # Executor crash (not a check failure): leave the throttle untouched
+        # so a retry within the interval is not silently swallowed.
         return ""
+    if throttled:
+        _write_throttle(repo_root, normalized, time.time() if now is None else now)
     return normalized_one_line(report)
 
 

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

@@ -18,7 +18,6 @@ from services.context_discovery import (
     implement_spec_entries,
     is_skill_path,
     skill_path,
-    use_claude_skill_context,
 )
 from services.context_jsonl import (
     ContextJsonlEntry,