@prismer/runtime 2.0.8 → 2.2.63

package/built-in-skills/skill-creator/scripts/run_eval.py

@@ -8,6 +8,8 @@ for a set of queries. Outputs results as JSON.
 import argparse
 import json
 import os
+import re
+import tempfile
 import select
 import subprocess
 import sys
@@ -16,7 +18,10 @@ import uuid
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
 
-from scripts.utils import parse_skill_md
+if __package__:
+    from .utils import parse_skill_md
+else:
+    from utils import parse_skill_md
 
 
 def find_project_root() -> Path:
@@ -33,153 +38,60 @@ def find_project_root() -> Path:
 
 
 def run_single_query(
-    query: str,
-    skill_name: str,
-    skill_description: str,
-    timeout: int,
-    project_root: str,
-    model: str | None = None,
+    query: str, skill_name: str, skill_description: str, timeout: int,
+    project_root: str, model: str | None = None,
 ) -> bool:
-    """Run a single query and return whether the skill was triggered.
-
-    Creates a command file in .claude/commands/ so it appears in Claude's
-    available_skills list, then runs `claude -p` with the raw query.
-    Uses --include-partial-messages to detect triggering early from
-    stream events (content_block_start) rather than waiting for the
-    full assistant message, which only arrives after tool execution.
-    """
-    unique_id = uuid.uuid4().hex[:8]
-    clean_name = f"{skill_name}-skill-{unique_id}"
-    project_commands_dir = Path(project_root) / ".claude" / "commands"
-    command_file = project_commands_dir / f"{clean_name}.md"
-
-    try:
-        project_commands_dir.mkdir(parents=True, exist_ok=True)
-        # Use YAML block scalar to avoid breaking on quotes in description
-        indented_desc = "\n  ".join(skill_description.split("\n"))
-        command_content = (
-            f"---\n"
-            f"description: |\n"
-            f"  {indented_desc}\n"
-            f"---\n\n"
-            f"# {skill_name}\n\n"
-            f"This skill handles: {skill_description}\n"
+    """Evaluate only a temporary probe skill; never write into the user's repo."""
+    if os.environ.get("PRISMER_ALLOW_PAID_EVAL") != "1":
+        raise PermissionError("Set PRISMER_ALLOW_PAID_EVAL=1 after approving evaluation cost")
+    if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", skill_name):
+        raise ValueError("Unsafe skill name")
+    if timeout <= 0:
+        raise ValueError("timeout must be positive")
+    clean_name = f"{skill_name}-skill-{uuid.uuid4().hex[:8]}"
+    with tempfile.TemporaryDirectory(prefix="skill-trigger-") as directory:
+        skill_dir = Path(directory) / ".claude" / "skills" / clean_name
+        skill_dir.mkdir(parents=True)
+        description = "\\n  ".join(skill_description.splitlines())
+        (skill_dir / "SKILL.md").write_text(
+            f"---\\nname: {clean_name}\\ndescription: |\\n  {description}\\n---\\n"
+            "Report that this probe skill was selected. Do not execute any other action.\\n",
+            encoding="utf-8",
         )
-        command_file.write_text(command_content)
-
-        cmd = [
-            "claude",
-            "-p", query,
-            "--output-format", "stream-json",
-            "--verbose",
-            "--include-partial-messages",
-        ]
+        cmd = ["claude", "-p", query, "--output-format", "stream-json", "--verbose",
+               "--bare", "--tools", "Read,Skill", "--allowedTools", "Read,Skill",
+               "--permission-mode", "dontAsk", "--strict-mcp-config",
+               "--mcp-config", '{"mcpServers":{}}', "--setting-sources", "",
+               "--no-session-persistence", "--max-budget-usd", "0.25"]
         if model:
             cmd.extend(["--model", model])
-
-        # Remove CLAUDECODE env var to allow nesting claude -p inside a
-        # Claude Code session. The guard is for interactive terminal conflicts;
-        # programmatic subprocess usage is safe.
-        env = {k: v for k, v in os.environ.items() if k != "CLAUDECODE"}
-
-        process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-            cwd=project_root,
-            env=env,
-        )
-
-        triggered = False
-        start_time = time.time()
-        buffer = ""
-        # Track state for stream event detection
-        pending_tool_name = None
-        accumulated_json = ""
-
-        try:
-            while time.time() - start_time < timeout:
-                if process.poll() is not None:
-                    remaining = process.stdout.read()
-                    if remaining:
-                        buffer += remaining.decode("utf-8", errors="replace")
-                    break
-
-                ready, _, _ = select.select([process.stdout], [], [], 1.0)
-                if not ready:
-                    continue
-
-                chunk = os.read(process.stdout.fileno(), 8192)
-                if not chunk:
-                    break
-                buffer += chunk.decode("utf-8", errors="replace")
-
-                while "\n" in buffer:
-                    line, buffer = buffer.split("\n", 1)
-                    line = line.strip()
-                    if not line:
-                        continue
-
-                    try:
-                        event = json.loads(line)
-                    except json.JSONDecodeError:
+        # communicate drains both pipes; errors are never scored as negatives.
+        completed = subprocess.run(cmd, cwd=directory, env=dict(os.environ),
+                                   capture_output=True, text=True, timeout=timeout)
+        if completed.returncode:
+            raise RuntimeError(f"Claude evaluation exited {completed.returncode}")
+        triggered, finished = False, False
+        for line in completed.stdout.splitlines():
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if event.get("type") == "assistant":
+                for block in event.get("message", {}).get("content", []):
+                    if block.get("type") != "tool_use":
                         continue
-
-                    # Early detection via stream events
-                    if event.get("type") == "stream_event":
-                        se = event.get("event", {})
-                        se_type = se.get("type", "")
-
-                        if se_type == "content_block_start":
-                            cb = se.get("content_block", {})
-                            if cb.get("type") == "tool_use":
-                                tool_name = cb.get("name", "")
-                                if tool_name in ("Skill", "Read"):
-                                    pending_tool_name = tool_name
-                                    accumulated_json = ""
-                                else:
-                                    return False
-
-                        elif se_type == "content_block_delta" and pending_tool_name:
-                            delta = se.get("delta", {})
-                            if delta.get("type") == "input_json_delta":
-                                accumulated_json += delta.get("partial_json", "")
-                                if clean_name in accumulated_json:
-                                    return True
-
-                        elif se_type in ("content_block_stop", "message_stop"):
-                            if pending_tool_name:
-                                return clean_name in accumulated_json
-                            if se_type == "message_stop":
-                                return False
-
-                    # Fallback: full assistant message
-                    elif event.get("type") == "assistant":
-                        message = event.get("message", {})
-                        for content_item in message.get("content", []):
-                            if content_item.get("type") != "tool_use":
-                                continue
-                            tool_name = content_item.get("name", "")
-                            tool_input = content_item.get("input", {})
-                            if tool_name == "Skill" and clean_name in tool_input.get("skill", ""):
-                                triggered = True
-                            elif tool_name == "Read" and clean_name in tool_input.get("file_path", ""):
-                                triggered = True
-                            return triggered
-
-                    elif event.get("type") == "result":
-                        return triggered
-        finally:
-            # Clean up process on any exit path (return, exception, timeout)
-            if process.poll() is None:
-                process.kill()
-                process.wait()
-
+                    args = block.get("input", {})
+                    if block.get("name") == "Skill":
+                        triggered |= clean_name in args.get("skill", "")
+                    elif block.get("name") == "Read":
+                        triggered |= clean_name in args.get("file_path", "")
+            elif event.get("type") == "result":
+                if event.get("is_error") or event.get("subtype") not in (None, "success"):
+                    raise RuntimeError("Claude evaluation returned an error result")
+                finished = True
+        if not finished:
+            raise RuntimeError("Claude evaluation produced no successful terminal result")
         return triggered
-    finally:
-        if command_file.exists():
-            command_file.unlink()
-
 
 def run_eval(
     eval_set: list[dict],
@@ -193,6 +105,14 @@ def run_eval(
     model: str | None = None,
 ) -> dict:
     """Run the full eval set and return results."""
+    if not eval_set or num_workers < 1 or runs_per_query < 1 or timeout <= 0:
+        raise ValueError('Non-empty eval set and positive workers/runs/timeout required')
+    if not 0 < trigger_threshold <= 1:
+        raise ValueError('trigger_threshold must be in (0, 1]')
+    if len({item['query'] for item in eval_set}) != len(eval_set):
+        raise ValueError('Duplicate queries make train/test membership ambiguous')
+    if len(eval_set) * runs_per_query > 300 or num_workers > 10:
+        raise ValueError('Evaluation exceeds 300-call or 10-worker safety budget')
     results = []
 
     with ProcessPoolExecutor(max_workers=num_workers) as executor:
@@ -221,8 +141,7 @@ def run_eval(
             try:
                 query_triggers[query].append(future.result())
             except Exception as e:
-                print(f"Warning: query failed: {e}", file=sys.stderr)
-                query_triggers[query].append(False)
+                raise RuntimeError('Evaluation incomplete; failed calls cannot count as negative triggers') from e
 
     for query, triggers in query_triggers.items():
         item = query_items[query]

package/built-in-skills/skill-creator/scripts/run_loop.py

@@ -15,27 +15,37 @@ import time
 import webbrowser
 from pathlib import Path
 
-from scripts.generate_report import generate_html
-from scripts.improve_description import improve_description
-from scripts.run_eval import find_project_root, run_eval
-from scripts.utils import parse_skill_md
+if __package__:
+    from .generate_report import generate_html
+    from .improve_description import improve_description
+    from .run_eval import find_project_root, run_eval
+    from .utils import parse_skill_md
+else:
+    from generate_report import generate_html
+    from improve_description import improve_description
+    from run_eval import find_project_root, run_eval
+    from utils import parse_skill_md
 
 
 def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
     """Split eval set into train and test sets, stratified by should_trigger."""
-    random.seed(seed)
+    rng = random.Random(seed)
+    if not 0 < holdout < 1:
+        raise ValueError('holdout must be between 0 and 1')
 
     # Separate by should_trigger
     trigger = [e for e in eval_set if e["should_trigger"]]
     no_trigger = [e for e in eval_set if not e["should_trigger"]]
 
     # Shuffle each group
-    random.shuffle(trigger)
-    random.shuffle(no_trigger)
+    if len(trigger) < 2 or len(no_trigger) < 2:
+        raise ValueError('Stratified holdout needs at least two positive and two negative queries')
+    rng.shuffle(trigger)
+    rng.shuffle(no_trigger)
 
     # Calculate split points
-    n_trigger_test = max(1, int(len(trigger) * holdout))
-    n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
+    n_trigger_test = min(len(trigger) - 1, max(1, int(len(trigger) * holdout)))
+    n_no_trigger_test = min(len(no_trigger) - 1, max(1, int(len(no_trigger) * holdout)))
 
     # Split
     test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
@@ -60,6 +70,8 @@ def run_loop(
     log_dir: Path | None = None,
 ) -> dict:
     """Run the eval + improvement loop."""
+    if max_iterations < 1 or not 0 <= holdout < 1:
+        raise ValueError('Positive max_iterations and holdout in [0, 1) required')
     project_root = find_project_root()
     name, original_description, content = parse_skill_md(skill_path)
     current_description = description_override or original_description
@@ -213,13 +225,9 @@ def run_loop(
 
         current_description = new_description
 
-    # Find the best iteration by TEST score (or train if no test set)
-    if test_set:
-        best = max(history, key=lambda h: h["test_passed"] or 0)
-        best_score = f"{best['test_passed']}/{best['test_total']}"
-    else:
-        best = max(history, key=lambda h: h["train_passed"])
-        best_score = f"{best['train_passed']}/{best['train_total']}"
+    # Selection cannot use holdout scores; improvement also receives train only.
+    best = max(history, key=lambda h: h['train_passed'])
+    best_score = f"{best['train_passed']}/{best['train_total']}"
 
     if verbose:
         print(f"\nExit reason: {exit_reason}", file=sys.stderr)

package/built-in-skills/slack-gif-creator/SKILL.md

@@ -1,9 +1,29 @@
 ---
 name: slack-gif-creator
+scope: persistence
 description: Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."
 license: Complete terms in LICENSE.txt
+config:
+  - key: SLACK_WEBHOOK_URL
+    type: secret
+    required: false
+    default: null
+    bindable: [role, agent]
+    description: Optional Slack Incoming Webhook to post the finished GIF to a channel directly. Webhook URLs embed a token — treated as a secret.
+    prompt:
+      zh: "要把 GIF 直接发到 Slack 频道吗？请提供 Incoming Webhook URL。"
+      en: "Should the GIF be posted to a Slack channel directly? Provide the Incoming Webhook URL."
 ---
 
+## Optional: post directly to Slack
+
+If `SLACK_WEBHOOK_URL` is present in your environment, you may additionally
+post the finished GIF to that Slack channel (upload the file where the
+webhook workflow expects it, or send a message linking the delivered asset).
+Never print the webhook URL itself into chat, files, or logs. When the
+variable is absent, skip this step silently — delivery below is the only
+required output.
+
 ## Delivering the GIF
 
 When this skill finishes producing an animated GIF (`output.gif`), deliver

package/built-in-skills/slack-gif-creator/core/gif_builder.py

@@ -29,7 +29,10 @@ class GIFBuilder:
         self.width = width
         self.height = height
         self.fps = fps
+        if fps <= 0 or width <= 0 or height <= 0:
+            raise ValueError('Dimensions and fps must be positive')
         self.frames: list[np.ndarray] = []
+        self._frame_ticks: list[int] = []
 
     def add_frame(self, frame: np.ndarray | Image.Image):
         """
@@ -50,6 +53,7 @@ class GIFBuilder:
             frame = np.array(pil_frame)
 
         self.frames.append(frame)
+        self._frame_ticks.append(1)
 
     def add_frames(self, frames: list[np.ndarray | Image.Image]):
         """Add multiple frames at once."""
@@ -136,6 +140,7 @@ class GIFBuilder:
             return 0
 
         deduplicated = [self.frames[0]]
+        ticks = [self._frame_ticks[0]]
         removed_count = 0
 
         for i in range(1, len(self.frames)):
@@ -151,10 +156,13 @@ class GIFBuilder:
             # High threshold (0.9995+) means only remove nearly identical frames
             if similarity < threshold:
                 deduplicated.append(self.frames[i])
+                ticks.append(self._frame_ticks[i])
             else:
+                ticks[-1] += self._frame_ticks[i]
                 removed_count += 1
 
         self.frames = deduplicated
+        self._frame_ticks = ticks
         return removed_count
 
     def save(
@@ -213,6 +221,8 @@ class GIFBuilder:
                 )
                 # Keep every nth frame to get close to 12 frames
                 keep_every = max(1, len(self.frames) // 12)
+                self._frame_ticks = [sum(self._frame_ticks[i:i + keep_every])
+                                     for i in range(0, len(self.frames), keep_every)]
                 self.frames = [
                     self.frames[i] for i in range(0, len(self.frames), keep_every)
                 ]
@@ -221,7 +231,7 @@ class GIFBuilder:
         optimized_frames = self.optimize_colors(num_colors, use_global_palette=True)
 
         # Calculate frame duration in milliseconds
-        frame_duration = 1000 / self.fps
+        frame_duration = [1000 * ticks / self.fps for ticks in self._frame_ticks]
 
         # Save GIF
         imageio.imwrite(
@@ -242,7 +252,7 @@ class GIFBuilder:
             "dimensions": f"{self.width}x{self.height}",
             "frame_count": len(optimized_frames),
             "fps": self.fps,
-            "duration_seconds": len(optimized_frames) / self.fps,
+            "duration_seconds": sum(self._frame_ticks) / self.fps,
             "colors": num_colors,
         }
 
@@ -267,3 +277,4 @@ class GIFBuilder:
     def clear(self):
         """Clear all frames (useful for creating multiple GIFs)."""
         self.frames = []
+        self._frame_ticks = []

package/built-in-skills/slack-gif-creator/core/validators.py

@@ -9,7 +9,8 @@ from pathlib import Path
 
 
 def validate_gif(
-    gif_path: str | Path, is_emoji: bool = True, verbose: bool = True
+    gif_path: str | Path, is_emoji: bool = True, verbose: bool = True,
+    max_bytes: int = 5 * 1024 * 1024,
 ) -> tuple[bool, dict]:
     """
     Validate GIF for Slack (dimensions, size, frame count).
@@ -25,6 +26,8 @@ def validate_gif(
     from PIL import Image
 
     gif_path = Path(gif_path)
+    if max_bytes <= 0:
+        raise ValueError('max_bytes must be positive')
 
     if not gif_path.exists():
         return False, {"error": f"File not found: {gif_path}"}
@@ -37,21 +40,25 @@ def validate_gif(
     # Get dimensions and frame info
     try:
         with Image.open(gif_path) as img:
+            if img.format != 'GIF':
+                return False, {'error': 'Input must be a GIF, not ' + str(img.format)}
             width, height = img.size
 
             # Count frames
             frame_count = 0
+            duration_ms = 0
             try:
                 while True:
                     img.seek(frame_count)
+                    img.load()
+                    duration_ms += img.info.get('duration', 0)
                     frame_count += 1
             except EOFError:
                 pass
 
             # Get duration
             try:
-                duration_ms = img.info.get("duration", 100)
-                total_duration = (duration_ms * frame_count) / 1000
+                total_duration = duration_ms / 1000
                 fps = frame_count / total_duration if total_duration > 0 else 0
             except:
                 total_duration = None
@@ -73,9 +80,12 @@ def validate_gif(
         )
         dim_pass = aspect_ratio <= 2.0 and 320 <= min(width, height) <= 640
 
+    passes = dim_pass and size_bytes <= max_bytes and frame_count > 0
     results = {
         "file": str(gif_path),
-        "passes": dim_pass,
+        "passes": passes,
+        "size_pass": size_bytes <= max_bytes,
+        "max_bytes": max_bytes,
         "width": width,
         "height": height,
         "size_kb": size_kb,
@@ -112,10 +122,10 @@ def validate_gif(
                 f"  Note: {'Emoji should be 128x128' if is_emoji else 'Unusual dimensions for Slack'}"
             )
 
-        if size_mb > 5.0:
-            print(f"  Note: Large file size - consider fewer frames/colors")
+        if size_bytes > max_bytes:
+            print(f"  Failed: exceeds configured size budget ({max_bytes} bytes)")
 
-    return dim_pass, results
+    return passes, results
 
 
 def is_slack_ready(

package/built-in-skills/tasks/SKILL.md

@@ -1,5 +1,6 @@
 ---
 name: tasks
+scope: common
 description: Manage Prismer workspace tasks across the full Kanban lifecycle — create, list, inspect, update, complete, approve, reject, cancel. Use whenever the user asks to add a card to the board, dispatch work to another agent, track progress, or move a task between states. Executes via the `cloud task` CLI.
 ---
 
@@ -11,13 +12,22 @@ Use this skill to drive the **workspace Kanban** end-to-end. Tasks are durable b
 
 When the user asks you to **assign / delegate / hand off** work to ANOTHER agent (e.g. "create kanban tasks and assign to @research-agent", "give this to Bob"):
 
-1. **Call `cloud task create --assignee-name <agent>` (or `--assignee-id`).** That is the ONLY legitimate delegation path. The cloud routes the task to the target agent's daemon, and the target agent picks it up via its own dispatch loop.
-2. **STOP** as soon as `cloud task create` returns task IDs. Reply to the user with the IDs / titles. **Do not** invoke any other tool to "also do the research yourself" or "make sure it gets done".
+1. **Call `cloud task create --assignee-name <agent>` (or `--assignee-id`).** That is the ONLY legitimate delegation path. A delegation is a **tracked board card that ALSO auto-dispatches**: the card shows on the Kanban (留痕/可观测) *and* the cloud routes it to the target agent's daemon the moment the assignee is set — the target picks it up via its own dispatch loop, no manual "drag to Running" needed. (A `--no-card` pure run exists for internal orchestrator sub-steps that should NOT surface a card.)
+2. **For a delegation-only request, stop after reporting the returned IDs / titles.** If the user also requested orchestration, follow-through, or result collection, continue read-only status/result collection with bounded waits as described below. Never duplicate the assignee's work yourself.
 3. **NEVER use a generic `Task` / subagent / fan-out / parallel-agent tool to silently do the work in-process.** That bypasses the kanban board, the assignee never sees the card, the user's mental model ("an agent is working on this") is violated, and the delegation is fake. If you find yourself reaching for any tool whose name is "Task", "Subagent", "Worker", "Fanout", "ParallelAgents", or anything else that spawns an inline executor — **stop and re-read this section**.
 4. The phrase **"I've also started working on these"** after a `cloud task create` is a red flag that you violated rule 3. The correct phrase is **"Tasks created and assigned. @research-agent will pick up the cards."**
 
 This is non-negotiable. Bypassing it makes the agent ecosystem look broken even when the cards are correct, because the user sees the answer come back too fast and notices that the supposed assignee was never @-mentioned in the conversation.
 
+## ↩️ 结果回流 — 委派后怎么拿到结果（HARD）
+
+委派出去之后，**结果不会自动回流**到你的对话或 run —— 没有回调、没有自动推送。被派的 agent 在它**自己的独立 context** 里执行（不进你当前这条会话、也不会在这里发言），产物落在 **task 卡 + 看板**上。所以：
+
+- **要看结果，你必须主动拉**：`cloud task get <taskId>` 读 `status` / `result` / 附件。`status=completed` 才算交付；`review` 等你 approve/reject。
+- **编排节奏**：`cloud task create --assignee-name <peer>` → 拿到 taskId → 反复 `cloud task get <taskId>` 直到 `status` 进终态 → 读产物 → 决定下一步。（有 `cloud task wait <id>` 时优先用它，省手搓轮询。）
+- **「看不到对方回复 ≠ 它没在干」**。被派 agent 沉默是正常的——它在独立 context 里跑，结果只在卡上。**绝不要**因为对话里没动静就自己把活重做一遍（那就是影子执行，违反上面的 Hard rules）。
+- 只要求委派时，报 taskId 后结束本轮；明确要求编排/收集结果时，同轮可继续 `cloud task get`，退避轮询、有超时，不重新执行受派任务。不要自行安排未来轮询或声称已有后台监控。
+
 ## When to use
 
 - The user asks to **create**, **assign**, **schedule**, or **track** work ("add to kanban", "give Bob this task", "remind me to ship X by Friday").
@@ -33,11 +43,17 @@ This is non-negotiable. Bypassing it makes the agent ecosystem look broken even
 
 ```
 pending → assigned → running → review → completed | failed | cancelled
-                                     ↓
-                                  approved / rejected (review only)
+              ↑                     ↓
+              └──── blocked ────────┤  (unblock returns to assigned)
+                                    ↓
+                             awaiting_approval
+                                    ↓
+                        approved / rejected (back to review)
 ```
 
-A `work_item` shows on the Kanban; a `goal` shows on the Goals lane. Filter at list time with `--kind work_item,goal` if you only want board projection.
+Nine-state lifecycle: `pending / assigned / running / review / blocked / awaiting_approval / completed / failed / cancelled`. `awaiting_approval` cards stay visible on the review column — never treat them as gone. `blocked` has its own column.
+
+A `work_item` shows on the Kanban; a `goal` shows on the Goals lane. Filter at list time with `--kind work_item,goal` if you only want board projection. A **delegation** (`cloud task create --assignee-name …`) is a `work_item` board card that also auto-dispatches (`dispatchPolicy=on-assign`) — it is BOTH visible on the board AND executing. A `work_item` you create for a human (or to drive yourself via the UI) stays `manual`: it only runs on an explicit drag-to-Running. **Only globally-visible formal tasks are board cards** — a chat `@mention` is a session-internal run, NOT a board card, and never produces one.
 
 ## Permission model (v2.0 — `release 200` state machine)
 
@@ -267,7 +283,7 @@ You MUST also confirm:
 
 ### As a verifier agent (when you receive task.verify.requested)
 
-You will receive an IM message:
+You will receive a task dispatch message:
 
     type: task.verify.requested
     taskId: ...
@@ -332,7 +348,7 @@ cloud task apply-template <taskId> --template <id>       # adopt a template
 
 ## 产物输出（user-deliverable）
 
-**交付是显式的**（release202/09 P2 起）。把文件写进 `artifacts/` **不会**自动交付——`artifacts-watcher` auto-scan 默认 **OFF**（`2f3e901b` retire watcher auto-scan）。每个要给用户的产物都必须显式跑一条 `cloud deliver` / `cloud task attach`。
+**文件交付是显式的**（release202/09 P2 起）。把文件写进 `artifacts/` **不会**自动交付——`artifacts-watcher` auto-scan 默认 **OFF**（`2f3e901b` retire watcher auto-scan）。仅当 carrier 决策是文件时，才使用 `cloud deliver` / `cloud task attach` 显式交付该文件。
 
 ```bash
 # 1) 把最终产物写到 artifacts/（draft / 中间文件走 scratch，不会被交付）
@@ -345,39 +361,38 @@ cloud task attach  "${PRISMER_ARTIFACTS_DIR}/my-report.md"   # 动作 ③：挂
 
 > ⚠️ **写进 `artifacts/` ≠ 交付**。没有 auto-scan。每个文件都要显式 `cloud deliver`（聊天回复产物）或 `cloud task attach`（任务卡产物），否则用户收不到。`artifacts/` 放最终交付物，draft / 中间文件走 `scratch/`。
 
-> **Hermes 适配额外要求**：hermes 没有 per-dispatch env id（`PRISMER_RUN_ID` / `PRISMER_CONVERSATION_ID` 均 unset），裸 `cloud deliver <path>` 找不到 dispatch 会报错。必须从 `<execution_context>` 抄 `<run_id>` 和 `<conversation_id>` 当 flag 传：
+> **常态（含 hermes）：直接 `cloud deliver <abs-path>` 即可**——hermes 虽没有 per-dispatch env id（`PRISMER_RUN_ID` / `PRISMER_CONVERSATION_ID` unset），但 daemon（release203/15c）会按你的 agent 身份自动关联你**当前**的 dispatch，补全 run/conversation。spawn 适配器（claude-code / codex）env 已注入，同样无需 flag。
+> **仅以下情形才手传 flag**：(a) 你要对**另一个**（非当前）dispatch 交付；(b) daemon 返回 **409 歧义**（同 agent 多个并发 dispatch 无法区分）。这时才从 `<execution_context>` 抄 `<run_id>` / `<conversation_id>`：
 > ```bash
 > cloud deliver "<abs-path>" --run-id "<run_id>" --conversation-id "<conversation_id>"
 > ```
-> spawn 适配器（claude-code / codex / openclaw）env 已注入，无需这两个 flag。详见 `office-artifacts` SKILL（唯一交付契约）。
+> 详见 `office-artifacts` SKILL（唯一交付契约）。
 
 **Workflow**：
 
-1. 中间脚本 / draft 写到 `${PRISMER_SCRATCH_DIR}/`（scratch，不进 IMAsset、不交付）
+1. 中间脚本 / draft 写到 `${PRISMER_SCRATCH_DIR}/`（scratch，不进 Asset、不交付）
 2. 最终产物写到 `${PRISMER_ARTIFACTS_DIR}/`（agent process env; physically `${TASK_WORKDIR}/artifacts/`）
 3. **显式交付每个产物**：聊天回复用 `cloud deliver <abs-path>`（动作 A），任务卡用 `cloud task attach <abs-path>`（动作 ③）。命令成功会打印 `assetId`
 
-**禁止**：
-
-- 不要在对话里贴大段 markdown 充当 "产物"——实际产物必须落文件
-- 不要把 draft / 中间产物丢进 `artifacts/`——那里只放最终交付物（draft 走 `scratch/`）
-- 不要以为写进 `artifacts/` 就交付了——没有 auto-scan，必须显式 `cloud deliver` / `cloud task attach`
+### Carrier 选择与显式交付
 
-### 文档型交付物 = markdown 文件（不是 chat 长文）
+carrier 优先级是：**用户明确要求 > Runtime carrier directive > 已选内容 skill > task 默认**。`tasks` skill 只管任务与回执，不擅自把内容改成 Markdown 文件、Asset 或 Memory Page。
 
-**SOP（适用于一切「文档型」交付物：方案 / 报告 / 调研 / 规格 / 总结 / 评审记录…）**：
+1. **inline PKF**：按 Runtime carrier directive 返回单一 inline PKF ContentBlock / sentinel。不写文件，不调 `cloud deliver` / `cloud task attach`，不并行产出 `.md` / `.html` / `.css` / `.js`。
+2. **用户明确要求文件**：按用户指定格式或内容 skill 决定的格式写入 `${PRISMER_ARTIFACTS_DIR}/`，再显式调 `cloud deliver` / `cloud task attach`。不要另造 Markdown 投影。
+3. **Asset / Memory**：只有用户要求或 Runtime carrier directive 明确选中时才 materialize；必须以服务端返回的 id / path / version / hash 以及读回结果作为权威证据。
+4. **任务 evidence**：截图、benchmark JSON、日志等原始证据可作为明确文件附件显式 `cloud task attach`；它们不会改变主交付物的 carrier。
 
-1. 文档型最终产物**必须写成 markdown 文件**（`.md`），落到 `${PRISMER_ARTIFACTS_DIR}/`（agent process env；physically `${TASK_WORKDIR}/artifacts/`）。daemon artifacts-watcher 会自动把它注册成 task-bound IMAsset 并挂到本次 dispatch 的 `reply.assetIds`（见上「自动归档」）。
-2. chat 里的文字回复是 **summary / teaser**（一两句话点出产了什么、关键结论），**不是交付物本身**。交付物在产物资产里，用户在 task 详情的 Artifacts 看完整内容；下游 task 可经 Library 复用同一份 markdown 资产。
-3. **文件名 / 结构由 skill 按目的自定**——别套死 schema。一般约定：用有意义的文件名（如 `research-summary.md` / `design-review.md` / `q3-plan.md`），需要时拆多个文件。一个 task 可产多个 markdown。
-
-**为什么**：贴在对话里的长 markdown 是一次性的、不可复用、污染时间线、跨设备 / 刷新易丢；写成文件后它是有 hash、可预览、可 promote 到 Library Root、可被下游 task 引用的**资产**。chat 时间线的完成卡只 surface「N 个产物 →」，点进 task drawer 看正文。
+**禁止**：
 
-> 二进制 office 产物（DOCX/PPTX/XLSX/PDF）见 `office-artifacts` skill；markdown 文档型走本节。两者都落 `artifacts/`，区别只是格式。
+- inline 选中后并行生成 Markdown/HTML/CSS/JS 或附件；
+- 把 draft / 中间产物放进 `artifacts/`（draft 走 `scratch/`）；
+- 把“写进 `artifacts/`”当成已交付——auto-scan 是 OFF，文件 carrier 必须有显式 receipt；
+- 用 role 模板或 task 流程覆盖 Runtime carrier directive。
 
 **Self-check checkpoint**：
 
-`cloud task update --status review` 内嵌调用本地 daemon `/v1/checkpoints/pre_status_change`。该 hook 比较 `artifacts/` 内文件 sha256 与已 attach IMAsset.contentHash，若 diff 非空：
+`cloud task update --status review` 内嵌调用本地 daemon `/v1/checkpoints/pre_status_change`。该 hook 比较 `artifacts/` 内文件 sha256 与已 attach Asset.contentHash，若 diff 非空：
 
 - exit code = 12
 - stderr 列出未 attach 的文件路径 + hash + size