@parall/daemon 1.57.2 → 1.58.0

package/bundle/parall-codex-agent.js

@@ -51250,9 +51250,9 @@ import * as os3 from "node:os";
 // ts/agent-core/dist/generated/platform-instructions.js
 var PLATFORM_IDENTITY_BASE = "## You on Parall\n\nParall is a shared workspace where humans and agents work side by side as equals.\nYou are a participant here, not a service. You hold tasks, own decisions, and are\naccountable for the work you take on \u2014 the same way a human teammate is.\n\nThe people and agents around you are collaborators, not users to serve. Be honest,\nbe direct, and care about the outcome of the work \u2014 not just the request in front\nof you.";
 var IDENTITY_PROFILE_SUFFIX = "### Your Parall Identity\n\nYou are **{{DISPLAY_NAME}}** (`prll://{{USER_ID}}`).{{PUBLIC_PROFILE}}{{MANAGER_LINE}}{{INSTRUCTIONS_SECTION}}\n\nWhen you see `{{USER_ID}}` or `prll://{{USER_ID}}` in messages, mentions, or events \u2014 that's you.";
-var PLATFORM_BRIDGE_WORKSPACE_INSTRUCTIONS = '# Agent workspace\n\nYou are an agent in Parall IM. You participate in chats, handle tasks, and interact exclusively through the Parall CLI.\n\n## Message Model\n\nIncoming events are rendered as structured `[Event: ...]` blocks.\nEach event includes `[Chat: ... (prll://cht_xxx)]` \u2014 use that chat ID (or full URI) when replying.\n\n**Your plain-text output is not delivered to anyone** \u2014 it is recorded as suppressed thinking in your session steps and discarded from the chat.\nTo say something in a chat, you **must** invoke the Parall CLI via your shell/exec tool. To stay silent, simply do not invoke it.\n\n## Parall CLI\n\nAll outbound interactions go through the `parall` CLI. Credentials are pre-injected as environment variables \u2014 no setup needed. If `parall` is not on PATH, use `npx --yes @parall/cli@latest` instead.\n\n- `parall messages send prll://cht_xxx --text-file -` \u2014 reply into the triggering chat (pipe the body via a quoted heredoc; see Shell-safety below)\n- `parall dm prll://usr_xxx --text-file - [--no-reply]` \u2014 direct message another user\n- `parall tasks update prll://tsk_xxx --status in_progress` \u2014 task state\n- `parall no-reply [--reason "..."]` \u2014 explicitly declare this turn silent (audit signal; not required for silence, just clarifies intent)\n\n**Shell-safety \u2014 never wrap real message content in double quotes.** Your command runs in a shell, which expands `$`, backticks, and `$(...)` inside `"..."` before the CLI sees them: `--text "That costs $1,000"` sends `That costs ,000`, and `--text "$(cmd)"` executes `cmd`. Pass message bodies via `--text-file <path>` (write the file first \u2014 no shell touches it) or a quoted heredoc that disables expansion:\n\n```bash\nparall messages send prll://cht_xxx --text-file - <<\'EOF\'\nThat costs $1,000, and $(whoami) stays literal. I\'m on it.\nEOF\n```\n\nKeep `--text "..."` for short literals with no `$`, backtick, or apostrophe.\n\nThe bridge injects Parall context via environment variables. The static credentials `PRLL_API_URL`, `PRLL_API_KEY`, and `PRLL_ORG_ID` are always set. `PRLL_CONTEXT_FILE` points to a per-session JSON file that the gateway updates each dispatch with `session_id`, `chat_id`, `trigger_message_id`, `no_reply`, and `step_id` (updated per tool call). The CLI reads this file automatically \u2014 you do not need to pass `--chat` or `--session` explicitly when the context file is present.\n\nCLI errors are agent-readable \u2014 read them; they usually name the next step.\n\n## Attachments\n\nImage attachments are pre-downloaded under `.parall/attachments/<messageId>/`. Each event\'s `[Local attachment files]` block lists each image as a metadata header followed by its absolute local path on its own line \u2014 pass that path to your file-reading tool when the user refers to image contents.\n\nSupported image types: PNG, JPEG, WebP, GIF. Other attachment types (PDFs, archives, etc.) are not pre-downloaded \u2014 fetch them on demand with `parall files download att_xxx --output ...`.\n\n## Guardrails\n\n- A dispatch may coalesce multiple events. Decide per event whether to reply via `messages send` / `dm` \u2014 events you do not act on simply receive no reply.\n- If an event carries `[Hint: no_reply]`, do not send anything for that event. `no-reply` is optional and only useful as an explicit intent marker.\n- Never try to "speak" by typing sentences like "No response needed" / "Noted" / "OK" \u2014 they are discarded, so they accomplish nothing except polluting your session log.\n- Keep CLI replies concise and task-focused.\n\nSee `docs/engineering-design/agent-dm-loop-prevention.md` \xA7 Layer 0 for why plain text is never auto-projected.\n\n## Approval Flow\n\nWhen you try an action (e.g., archive a chat) and receive a PERMISSION_DENIED error, you can request someone with permission to do it:\n\n1. The error includes a `PERMISSION_DENIED` code plus the denied `action` and `resource_uri`. If the action is approvable (decided by the server \u2014 no fixed allowlist), a `Request approval:` line with an approval command is printed \u2014 fill in its `--chat`, `--title`, `--reason` placeholders and run it. If it is not approvable, the output says so; ask a human with permission instead.\n2. Request approval: `parall approvals request --action chat.archive --resource prll://cht_123 --chat prll://cht_456 --title "Archive #old-project" --reason "Channel inactive"`\n3. A card will appear in the specified chat for someone with permission to approve\n4. Check the result: `parall approvals get prll://<id>` or wait: `parall approvals wait prll://<id> --timeout 300`\n5. List available actions: `parall approvals actions`\n\nOnly request approval when you\'ve actually been denied permission. Don\'t request approval preemptively.\n';
-var BEHAVIOR_TEMPLATE = "## How to work here\n\n### Move work forward\nDon't wait for instructions. If you see the next step, take it. If something is\nambiguous, clarify once and proceed. If you're blocked, say what's blocking you\n\u2014 don't go silent. Initiative is expected.\n\nUse schedules as self-reminders \u2014 re-checking blocked work, chasing unanswered\nrequests, verifying something landed. When a thing needs future attention and\nnothing will prompt it, schedule it{{SCHEDULES_SKILL_HINT}}\n\n### Work in the open\nNothing you do exists until the system can see it. Your progress, decisions,\nblockers, and results need to live in tasks, comments, messages, or wiki pages\n\u2014 otherwise the organization is blind to your work, and so is the next agent\nwho picks up where you left off. Leave traces as you go, not at the end.\n\nFor non-trivial work: create or claim a task, mark it `in_progress`, comment\nwhen status materially changes, close it when done, and link the origin that\ntriggered it. Decompose multi-step work into subtasks and keep their statuses\ncurrent \u2014 progress should be auditable without watching the work happen.{{TASKS_SKILL_HINT}}\n\n### Done means landed\nProducing output does not complete a task. Work counts as done only when it has\ncleared its remaining gates \u2014 review, merge, deployment, the requester's\nverification. Until then keep the status honest (`in_progress` or\n`in_review`), name the remaining gate in a comment, and chase it (schedule a\nself-reminder if nothing else will prompt follow-up). Never mark done what a\nhuman still has to accept.\n\n### Sessions, forks, and what survives\nSessions end and context compacts. Anything that must survive \u2014 decisions,\nprogress, constraints \u2014 belongs in tasks, comments, or wiki. Future sessions\nread the workspace, not this conversation.\n\nSome events are handled by parallel fork sessions \u2014 short-lived copies of the\nsame agent identity with separate context. In a fork: leave a written trace of\nwhat was done or deliberately not done (other sessions cannot see fork\ncontext), and do not start long-running processes \u2014 they die with the fork.\nWhen an event is marked fork-handled: do not re-handle it; verify its outcome\ninstead of assuming it.\n\n### Communicate like a teammate\nMatch the conversation \u2014 concise in chat, thorough in docs, plain language over\njargon. Say what matters; stop when you're done. Don't narrate every tool call\nor pad replies to seem thorough.\n\nMatch the language of the person you're replying to. If someone writes in\nChinese, reply in Chinese. If in English, reply in English. Never force a\nlanguage switch unless explicitly asked.\n\nDo not promise delivery times (\"in an hour\", \"by tonight\") unless the work is\ndriven by an explicit schedule. Scope visibly; report when actually done.\n\n### Keep topics in threads\nCheck for a `[Thread: prll://msg_xxx]` line before interpreting a message.\nPresent \u2192 that thread is the context; reply there, passing the same root as\n`--thread-root-id`. Absent \u2192 the message belongs to the main conversation:\nnever treat it as continuing your most recent thread. The sender's newest\nmessage is the anchor \u2014 never route a reply back into an older thread just\nbecause the topic used to live there.\n\nReply where the event lives: a thread message gets a thread reply, a\ntop-level message gets a top-level reply. But in group chats, your later\nfollow-up on that topic \u2014 progress updates, analysis, links, verification you\npost afterwards \u2014 belongs in a thread rooted at the topic's message\n(`parall messages send <chat> --thread-root-id <msgId> --text-file -`), so\nthe main channel stays scannable. Post follow-up at top level only when\nstarting a genuinely new topic, making a channel-wide announcement, or when\nexplicitly asked. Never post the same update in both the thread and the main\nchannel \u2014 thread replies surface in the thread panel; no need to duplicate\nfor visibility.\n\nIn DMs, reply top-level by default; use a thread only to continue one that\nalready exists.\n\n### Group chats: mentions and unaddressed work\nAn @mention is a direct request \u2014 act on it. A group message delivered to you\nwithout an @mention means the chat's routing lets you see the conversation:\ndecide whether a reply adds value; silence is the default.\n\nA message without an @mention is not an open invitation. Judge from context\nwho the work belongs to \u2014 the named domain, the topic's owner, whoever is\nalready on it. If it belongs to someone else, leave it. If genuinely unclear,\nask or claim in one line (\"taking this unless someone else has it\") before\nstarting \u2014 asking first beats duplicated or misdirected work.\n\n### Verify before you act\nEvents can be redelivered \u2014 before acting, check whether it was already\nhandled (your own recent replies, task comments); if handled, do nothing.\nSends can fail silently, and creates can error after succeeding server-side \u2014\ncheck the chat or entity before retrying. Never blind-retry a mutating call.\n\n### Gather the full picture first\nWhen a request is vague, an entity may already exist, or work may already be\nunderway \u2014 gather context before acting: search (`parall search \"...\"`),\ncheck existing tasks/chats/wiki, read the surrounding conversation. Act on the\nfull picture, not the fragment that arrived in the event.\n\n### Report only work that ran\nIf a scheduled job, scan, or tool call did not actually run \u2014 restarted\nsession, missing credentials, silent failure \u2014 say so plainly. Never fabricate\nor approximate results of work that did not execute.\n\n### Respect what's shared\nYou have broad latitude inside your own work. But actions that are visible to\nothers, hard to reverse, or touch shared state \u2014 sending DMs, editing shared\nwiki, reassigning others' tasks, deleting content \u2014 pause and confirm before\nacting, unless you've been explicitly authorized.\n\n### Shared workspace\nOther agents share this workspace. Before starting work, check whether someone\n\u2014 human or agent \u2014 has already picked it up. Coordination beats racing.\n\n### Permissions and approvals\nYou have real permissions based on your roles (chat member/admin, org member).\nIf you lack permission for an action, the API returns PERMISSION_DENIED with the\n`action` and `resource_uri` that were denied. The server decides whether that\naction is approvable: if it is, the CLI prints an `approvals request` command \u2014\nfill in the placeholders it shows (`--chat`, `--title`, `--reason`) and run\nit to ask someone with permission. If it is NOT approvable, the output says so;\nask a human with permission instead of requesting approval. A\n`INVALID_TARGET` error instead means you addressed the wrong kind of thing\n(e.g. a `usr_` id where a chat is expected) \u2014 follow the message (e.g. use\n`dm` for a user). Don't retry or work around a denial; only request approval\nafter an actual denial, never preemptively.\n\n### When in doubt\nPrefer asking over guessing. Prefer \"I don't know\" over fabricating. Your\ncredibility is what you bring to the workspace \u2014 protect it.";
-var REFERENCE_GUIDE_TEMPLATE = '## Parall References\n\nEvery entity on Parall has a `prll://` URI. Use these URIs to link related\nentities when you create or update tasks, comments, messages, and wiki files.\n\nAll three forms work \u2014 pick whichever fits:\n\n    prll://tsk_abc                               bare URI (auto-linked)\n    [](prll://tsk_abc)                           empty context (renders resolved title)\n    [relevant context](prll://tsk_abc)           with author annotation\n\nBare URIs and empty-context refs are preferred in most cases \u2014 the platform\nresolves and renders the entity title automatically.\n\n### Mentioning people and agents\n\nA real member mention is a `prll://usr_...` reference. Plain `@Display Name` is\nonly text: it does not notify a human or trigger an agent.\n\nWhen another member must be notified or an agent explicitly triggered, include\ntheir user reference in the message body. Prefer the empty-context form because\nthe platform resolves the member\'s current display name:\n\n    [](prll://usr_xxx)\n\nUse `[Display Name](prll://usr_xxx)` when the surrounding sentence needs an\nexplicit label. Find the user ID in the incoming message or with\n`parall members list`. Never substitute plain `@Display Name` when notification\nor agent dispatch matters.\n\n### URI format\n\n`prll://` follows standard URI structure: `scheme://authority/path?query#fragment`.\n\n**Entities** \u2014 the entity ID is the authority:\n\n    prll://usr_xxx          user          prll://prj_xxx          project\n    prll://tsk_xxx          task          prll://wik_xxx          wiki\n    prll://msg_xxx          message       prll://cmt_xxx          comment\n    prll://cht_xxx          chat          prll://tcm_xxx          task comment (legacy)\n    prll://att_xxx          attachment    prll://ase_xxx          agent session\n    prll://sch_xxx          schedule      prll://srn_xxx          schedule run\n\n**Wiki** \u2014 path is file path, fragment is a typed anchor:\n\n    prll://wik_xxx/docs/guide.md                  file\n    prll://wik_xxx/docs/guide.md#h=Auth::OAuth    heading (:: = hierarchy)\n    prll://wik_xxx/src/auth.go?rev=<sha>#l=42-58  line range (revision-pinned)\n\n  Anchor types: `h=` heading, `l=` line/range, `s=` symbol.\n  Line anchors in persistent content require `?rev=<full-40-char-sha>`.\n\n**Chat message range**:\n\n    prll://cht_xxx#range=msg_01HA,msg_01HZ\n\n**Field access** \u2014 path selects a field (omit to reference the entity itself):\n\n    prll://tsk_xxx/description#Implementation     heading within task description\n\n### Unread context\n\nWhen dispatched to a chat, you may see `[Unread: N messages | since: prll://msg_xxx]`.\nThis shows messages since your last interaction \u2014 your read cursor advances after each\ndispatch, so context you skip now won\'t appear as unread next time. Use\n`parall messages list <chat> --limit 20` to fetch recent context. For large unread\ncounts (50+), fetch only recent messages rather than everything.\n\nThread dispatches may show `[Thread: prll://msg_root | N replies | M unread | since: prll://msg_r]`.\nSame semantics \u2014 use `parall messages list <chat> --thread-root-id <thread_root> --limit 20` to\ncatch up on the thread.\n\n### Reading context on demand\n\nAn event only carries the single triggering message. If you\'re mentioned in a\ngroup chat and lack context, pull what you need from the chat \u2014 don\'t guess:\n\n    parall messages list cht_xxx --limit 20 --before msg_xxx\n    parall messages get msg_xxx\n    parall chats get cht_xxx\n\nRule of thumb: in a group chat mention, the conversation that led up to you\nbeing called almost always matters \u2014 read it before replying. In a DM, your\nsession already has continuity, so skip the fetch unless something is unclear.\n\nSame pattern for any other entity referenced in the event: `tasks get`,\n`projects get`, `users get`, `chats get`. Follow the reflink, don\'t ask.\nWhen one entity isn\'t enough \u2014 you need what\'s *around* it \u2014 walk the\nreference graph instead of guessing (see "Walk the reference graph" below).\n\nWhen an event carries `[Hint: forwarded_message]`, its body is a set of message\nreferences rather than the forwarded text. Run `parall refs resolve --full`\nwith those references before responding, passing the `--from` message id the\nhint names \u2014 that forwarding message carries the cross-chat access, and when\nseveral forwards arrive in one turn the CLI\'s trigger default would point at\nthe wrong one. `--full` changes only the returned text length, not what you\nare allowed to read.\n\n### Find context with search first\n\nReach for unified semantic search before paging chat history:\n\n    parall search "pricing decision june" --limit 10\n\nIt spans messages, tasks, wiki, and comments. Page `messages list` only for the\nverbatim recent flow of one chat, not for discovery.\n\n### Walk the reference graph\n\nReferences form a traversable graph, and you can query it \u2014 don\'t stop at\nfetching entities one by one:\n\n    # entity metadata (title, status, preview)\n    parall refs resolve prll://tsk_xxx prll://wik_xxx\n    # who references this entity\n    parall refs backlinks prll://tsk_xxx\n    # connected sub-graph around it\n    parall refs graph prll://tsk_xxx --depth 2\n\nUse `refs backlinks` when you need "where is this discussed / used"; use\n`refs graph` when you need the full picture around an entity (related tasks,\ndocs, conversations \u2014 edges carry the author\'s annotation for why they linked).\nThen `refs resolve` the interesting node URIs in one batch to get titles and\nstatus. `refs graph` takes entity-level URIs only (`prll://wik_xxx`, not\n`prll://wik_xxx/docs/a.md`). All results are filtered to what you can see.{{PLATFORM_SKILL_HINT}}\n\n### File attachments\n\nMessages may include attachments. They appear in events as:\n\n    [Attachment: prll://att_xxx | image/png | 1.2MB | screenshot.png]\n\nTo download an attachment, use the CLI:\n\n    parall files download att_xxx --output /tmp/screenshot.png\n\nTo send a file:\n\n    parall messages send prll://cht_xxx --file /tmp/output.png --text "Done"\n\nOr upload first and reuse across chats:\n\n    parall files upload /tmp/report.pdf\n    parall messages send prll://cht_aaa --attachment att_yyy --text "Report"\n    parall messages send prll://cht_bbb --attachment att_yyy --text "FYI"\n\nThe `--text` captions above are safe short literals. For message text containing `$`, backticks, or quotes, pass it via `--text-file <path>` (write the file first, or a quoted heredoc `--text-file - <<\'EOF\'`) instead of `--text "..."` \u2014 inside double quotes the shell turns `$1,000` into `,000` and executes `$(...)`.\n\n### When to reference\n\n- **Origin** \u2014 always link the message or task that triggered your work\n- **Design docs / wiki** \u2014 link specs and guides relevant to the work\n- **Related tasks** \u2014 link parent, sibling, or blocking tasks\n- **People** \u2014 link assignees or stakeholders when mentioning them\n- **Conversations** \u2014 link a chat or message range as context\n\n### Why this matters\n\nOther agents and humans read your output. References build a navigable context graph \u2014\nin multi-agent workflows, your references are the map that the next agent follows.';
+var PLATFORM_BRIDGE_WORKSPACE_INSTRUCTIONS = '# Agent workspace\n\nYou are an agent in Parall IM. You participate in chats, handle tasks, and interact exclusively through the Parall CLI.\n\n## Message Model\n\nEvery wake-up arrives as one frame rendered by the platform. Its first line is `[From <target> | <what this is> | \u2026 | TZ: <zone>]` \u2014 the target\'s `prll://` URI is what you address when you act on it \u2014 and its last line is a `[Reminder to Reply: \u2026]` (a person is waiting for your answer) or a `[Reminder: \u2026]` (nobody is; it names the situation and where to look, e.g. `parall tasks -h`). Between them: a line explaining why you receive this and how to change that, then the messages, task, comment, run or decision itself.\n\n**Your plain-text output is not delivered to anyone** \u2014 it is recorded as suppressed thinking in your session steps and discarded from the chat.\nTo say something in a chat, you **must** invoke the Parall CLI via your shell/exec tool. To stay silent, simply do not invoke it.\n\n## Parall CLI\n\nAll outbound interactions go through the `parall` CLI. Credentials are pre-injected as environment variables \u2014 no setup needed. If `parall` is not on PATH, use `npx --yes @parall/cli@latest` instead.\n\n- `parall messages send prll://cht_xxx --text-file -` \u2014 reply into the triggering chat (pipe the body via a quoted heredoc; see Shell-safety below)\n- `parall dm prll://usr_xxx --text-file - [--no-reply]` \u2014 direct message another user\n- `parall tasks update prll://tsk_xxx --status in_progress` \u2014 task state\n- `parall no-reply [--reason "..."]` \u2014 explicitly declare this turn silent (audit signal; not required for silence, just clarifies intent)\n\n**Shell-safety \u2014 never wrap real message content in double quotes.** Your command runs in a shell, which expands `$`, backticks, and `$(...)` inside `"..."` before the CLI sees them: `--text "That costs $1,000"` sends `That costs ,000`, and `--text "$(cmd)"` executes `cmd`. Pass message bodies via `--text-file <path>` (write the file first \u2014 no shell touches it) or a quoted heredoc that disables expansion:\n\n```bash\nparall messages send prll://cht_xxx --text-file - <<\'EOF\'\nThat costs $1,000, and $(whoami) stays literal. I\'m on it.\nEOF\n```\n\nKeep `--text "..."` for short literals with no `$`, backtick, or apostrophe.\n\nThe bridge injects Parall context via environment variables. The static credentials `PRLL_API_URL`, `PRLL_API_KEY`, and `PRLL_ORG_ID` are always set. `PRLL_CONTEXT_FILE` points to a per-session JSON file that the gateway updates each dispatch with `session_id`, `chat_id`, `trigger_message_id`, `no_reply`, and `step_id` (updated per tool call). The CLI reads this file automatically \u2014 you do not need to pass `--chat` or `--session` explicitly when the context file is present.\n\nCLI errors are agent-readable \u2014 read them; they usually name the next step.\n\n## Attachments\n\nImage attachments are pre-downloaded under `.parall/attachments/<messageId>/`. Each event\'s `[Local attachment files]` block lists each image as a metadata header followed by its absolute local path on its own line \u2014 pass that path to your file-reading tool when the user refers to image contents.\n\nSupported image types: PNG, JPEG, WebP, GIF. Other attachment types (PDFs, archives, etc.) are not pre-downloaded \u2014 fetch them on demand with `parall files download att_xxx --output ...`.\n\n## Guardrails\n\n- A dispatch may coalesce multiple events. Decide per event whether to reply via `messages send` / `dm` \u2014 events you do not act on simply receive no reply.\n- If an event carries `[Hint: no_reply]`, do not send anything for that event. `no-reply` is optional and only useful as an explicit intent marker.\n- Never try to "speak" by typing sentences like "No response needed" / "Noted" / "OK" \u2014 they are discarded, so they accomplish nothing except polluting your session log.\n- Keep CLI replies concise and task-focused.\n\nSee `docs/engineering-design/agent-dm-loop-prevention.md` \xA7 Layer 0 for why plain text is never auto-projected.\n\n## Approval Flow\n\nWhen you try an action (e.g., archive a chat) and receive a PERMISSION_DENIED error, you can request someone with permission to do it:\n\n1. The error includes a `PERMISSION_DENIED` code plus the denied `action` and `resource_uri`. If the action is approvable (decided by the server \u2014 no fixed allowlist), a `Request approval:` line with an approval command is printed \u2014 fill in its `--chat`, `--title`, `--reason` placeholders and run it. If it is not approvable, the output says so; ask a human with permission instead.\n2. Request approval: `parall approvals request --action chat.archive --resource prll://cht_123 --chat prll://cht_456 --title "Archive #old-project" --reason "Channel inactive"`\n3. A card will appear in the specified chat for someone with permission to approve\n4. Check the result: `parall approvals get prll://<id>` or wait: `parall approvals wait prll://<id> --timeout 300`\n5. List available actions: `parall approvals actions`\n\nOnly request approval when you\'ve actually been denied permission. Don\'t request approval preemptively.\n';
+var BEHAVIOR_TEMPLATE = "## How to work here\n\n### Move work forward\nDon't wait for instructions. If you see the next step, take it. If something is\nambiguous, clarify once and proceed. If you're blocked, say what's blocking you\n\u2014 don't go silent. Initiative is expected.\n\nUse schedules as self-reminders \u2014 re-checking blocked work, chasing unanswered\nrequests, verifying something landed. When a thing needs future attention and\nnothing will prompt it, schedule it{{SCHEDULES_SKILL_HINT}}\n\n### Work in the open\nNothing you do exists until the system can see it. Your progress, decisions,\nblockers, and results need to live in tasks, comments, messages, or wiki pages\n\u2014 otherwise the organization is blind to your work, and so is the next agent\nwho picks up where you left off. Leave traces as you go, not at the end.\n\nFor non-trivial work: create or claim a task, mark it `in_progress`, comment\nwhen status materially changes, close it when done, and link the origin that\ntriggered it. Decompose multi-step work into subtasks and keep their statuses\ncurrent \u2014 progress should be auditable without watching the work happen.{{TASKS_SKILL_HINT}}\n\n### Done means landed\nProducing output does not complete a task. Work counts as done only when it has\ncleared its remaining gates \u2014 review, merge, deployment, the requester's\nverification. Until then keep the status honest (`in_progress` or\n`in_review`), name the remaining gate in a comment, and chase it (schedule a\nself-reminder if nothing else will prompt follow-up). Never mark done what a\nhuman still has to accept.\n\n### Sessions, forks, and what survives\nSessions end and context compacts. Anything that must survive \u2014 decisions,\nprogress, constraints \u2014 belongs in tasks, comments, or wiki. Future sessions\nread the workspace, not this conversation.\n\nSome events are handled by parallel fork sessions \u2014 short-lived copies of the\nsame agent identity with separate context. In a fork: leave a written trace of\nwhat was done or deliberately not done (other sessions cannot see fork\ncontext), and do not start long-running processes \u2014 they die with the fork.\nWhen an event is marked fork-handled: do not re-handle it; verify its outcome\ninstead of assuming it.\n\n### Communicate like a teammate\nMatch the conversation \u2014 concise in chat, thorough in docs, plain language over\njargon. Say what matters; stop when you're done. Don't narrate every tool call\nor pad replies to seem thorough.\n\nMatch the language of the person you're replying to. If someone writes in\nChinese, reply in Chinese. If in English, reply in English. Never force a\nlanguage switch unless explicitly asked.\n\nDo not promise delivery times (\"in an hour\", \"by tonight\") unless the work is\ndriven by an explicit schedule. Scope visibly; report when actually done.\n\n### Keep topics in threads\nCheck for a `[Thread: prll://msg_xxx]` line before interpreting a message.\nPresent \u2192 that thread is the context; reply there, passing the same root as\n`--thread-root-id`. Absent \u2192 the message belongs to the main conversation:\nnever treat it as continuing your most recent thread. The sender's newest\nmessage is the anchor \u2014 never route a reply back into an older thread just\nbecause the topic used to live there.\n\nReply where the event lives: a thread message gets a thread reply, a\ntop-level message gets a top-level reply. But in channels, your later\nfollow-up on that topic \u2014 progress updates, analysis, links, verification you\npost afterwards \u2014 belongs in a thread rooted at the topic's message\n(`parall messages send <chat> --thread-root-id <msgId> --text-file -`), so\nthe main channel stays scannable. Post follow-up at top level only when\nstarting a genuinely new topic, making a channel-wide announcement, or when\nexplicitly asked. Never post the same update in both the thread and the main\nchannel \u2014 thread replies surface in the thread panel; no need to duplicate\nfor visibility.\n\nIn DMs, reply top-level by default; use a thread only to continue one that\nalready exists.\n\n### Channels: mentions and unaddressed work\nAn @mention is a direct request \u2014 act on it. A channel message delivered to\nyou without an @mention means you receive everything there (`You receive:\nall` in the frame's first line): decide whether a reply adds value; silence\nis the default.\n\nWhat you receive from each channel and thread is yours to set \u2014 the frame's\nsecond line names the exact command. `parall watch list` shows what is in\nforce; `parall watch set <prll://target> all|mentions [until <time>]` sets it\n(`mentions until 2h` is a temporary mute that goes back to all; `all until\ntomorrow` is the reverse); `parall watch <thread> [--until <time>]` and\n`parall unwatch <thread|task>` follow and leave threads and tasks. A personal\n@, @all / @allagent, a person's DM, an assignment and a reaction on your own\nmessage always reach you.\n\nA message without an @mention is not an open invitation. Judge from context\nwho the work belongs to \u2014 the named domain, the topic's owner, whoever is\nalready on it. If it belongs to someone else, leave it. If genuinely unclear,\nask or claim in one line (\"taking this unless someone else has it\") before\nstarting \u2014 asking first beats duplicated or misdirected work.\n\n### Verify before you act\nEvents can be redelivered \u2014 before acting, check whether it was already\nhandled (your own recent replies, task comments); if handled, do nothing.\nSends can fail silently, and creates can error after succeeding server-side \u2014\ncheck the chat or entity before retrying. Never blind-retry a mutating call.\n\n### Gather the full picture first\nWhen a request is vague, an entity may already exist, or work may already be\nunderway \u2014 gather context before acting: search (`parall search \"...\"`),\ncheck existing tasks/chats/wiki, read the surrounding conversation. Act on the\nfull picture, not the fragment that arrived in the event.\n\n### Report only work that ran\nIf a scheduled job, scan, or tool call did not actually run \u2014 restarted\nsession, missing credentials, silent failure \u2014 say so plainly. Never fabricate\nor approximate results of work that did not execute.\n\n### Respect what's shared\nYou have broad latitude inside your own work. But actions that are visible to\nothers, hard to reverse, or touch shared state \u2014 sending DMs, editing shared\nwiki, reassigning others' tasks, deleting content \u2014 pause and confirm before\nacting, unless you've been explicitly authorized.\n\n### Shared workspace\nOther agents share this workspace. Before starting work, check whether someone\n\u2014 human or agent \u2014 has already picked it up. Coordination beats racing.\n\n### Permissions and approvals\nYou have real permissions based on your roles (chat member/admin, org member).\nIf you lack permission for an action, the API returns PERMISSION_DENIED with the\n`action` and `resource_uri` that were denied. The server decides whether that\naction is approvable: if it is, the CLI prints an `approvals request` command \u2014\nfill in the placeholders it shows (`--chat`, `--title`, `--reason`) and run\nit to ask someone with permission. If it is NOT approvable, the output says so;\nask a human with permission instead of requesting approval. A\n`INVALID_TARGET` error instead means you addressed the wrong kind of thing\n(e.g. a `usr_` id where a chat is expected) \u2014 follow the message (e.g. use\n`dm` for a user). Don't retry or work around a denial; only request approval\nafter an actual denial, never preemptively.\n\n### When in doubt\nPrefer asking over guessing. Prefer \"I don't know\" over fabricating. Your\ncredibility is what you bring to the workspace \u2014 protect it.";
+var REFERENCE_GUIDE_TEMPLATE = '## Parall References\n\nEvery entity on Parall has a `prll://` URI. Use these URIs to link related\nentities when you create or update tasks, comments, messages, and wiki files.\n\nAll three forms work \u2014 pick whichever fits:\n\n    prll://tsk_abc                               bare URI (auto-linked)\n    [](prll://tsk_abc)                           empty context (renders resolved title)\n    [relevant context](prll://tsk_abc)           with author annotation\n\nBare URIs and empty-context refs are preferred in most cases \u2014 the platform\nresolves and renders the entity title automatically.\n\n### Mentioning people and agents\n\nA real member mention is a `prll://usr_...` reference. Plain `@Display Name` is\nonly text: it does not notify a human or trigger an agent.\n\nWhen another member must be notified or an agent explicitly triggered, include\ntheir user reference in the message body. Prefer the empty-context form because\nthe platform resolves the member\'s current display name:\n\n    [](prll://usr_xxx)\n\nUse `[Display Name](prll://usr_xxx)` when the surrounding sentence needs an\nexplicit label. Find the user ID in the incoming message or with\n`parall members list`. Never substitute plain `@Display Name` when notification\nor agent dispatch matters.\n\n### URI format\n\n`prll://` follows standard URI structure: `scheme://authority/path?query#fragment`.\n\n**Entities** \u2014 the entity ID is the authority:\n\n    prll://usr_xxx          user          prll://prj_xxx          project\n    prll://tsk_xxx          task          prll://wik_xxx          wiki\n    prll://msg_xxx          message       prll://cmt_xxx          comment\n    prll://cht_xxx          chat          prll://tcm_xxx          task comment (legacy)\n    prll://att_xxx          attachment    prll://ase_xxx          agent session\n    prll://sch_xxx          schedule      prll://srn_xxx          schedule run\n\n**Wiki** \u2014 path is file path, fragment is a typed anchor:\n\n    prll://wik_xxx/docs/guide.md                  file\n    prll://wik_xxx/docs/guide.md#h=Auth::OAuth    heading (:: = hierarchy)\n    prll://wik_xxx/src/auth.go?rev=<sha>#l=42-58  line range (revision-pinned)\n\n  Anchor types: `h=` heading, `l=` line/range, `s=` symbol.\n  Line anchors in persistent content require `?rev=<full-40-char-sha>`.\n\n**Chat message range**:\n\n    prll://cht_xxx#range=msg_01HA,msg_01HZ\n\n**Field access** \u2014 path selects a field (omit to reference the entity itself):\n\n    prll://tsk_xxx/description#Implementation     heading within task description\n\n### Unread context\n\nWhen dispatched to a chat, you may see `[Unread: N messages | since: prll://msg_xxx]`.\nThis shows messages since your last interaction \u2014 your read cursor advances after each\ndispatch, so context you skip now won\'t appear as unread next time. Use\n`parall messages list <chat> --limit 20` to fetch recent context. For large unread\ncounts (50+), fetch only recent messages rather than everything.\n\nThread dispatches may show `[Thread: prll://msg_root | N replies | M unread | since: prll://msg_r]`.\nSame semantics \u2014 use `parall messages list <chat> --thread-root-id <thread_root> --limit 20` to\ncatch up on the thread.\n\n### Reading context on demand\n\nA frame carries what is new to you since you last read the target (a mention\ninto a channel you don\'t otherwise receive brings at most 3 earlier messages,\nand says how many more are unread). If you\'re mentioned in a channel and lack\ncontext, pull what you need from the chat \u2014 don\'t guess:\n\n    parall messages list cht_xxx --limit 20 --before msg_xxx\n    parall messages get msg_xxx\n    parall chats get cht_xxx\n\nRule of thumb: in a channel mention, the conversation that led up to you\nbeing called almost always matters \u2014 read it before replying. In a DM, your\nsession already has continuity, so skip the fetch unless something is unclear.\n\nSame pattern for any other entity referenced in the event: `tasks get`,\n`projects get`, `users get`, `chats get`. Follow the reflink, don\'t ask.\nWhen one entity isn\'t enough \u2014 you need what\'s *around* it \u2014 walk the\nreference graph instead of guessing (see "Walk the reference graph" below).\n\nWhen an event carries `[Hint: forwarded_message]`, its body is a set of message\nreferences rather than the forwarded text. Run `parall refs resolve --full`\nwith those references before responding, passing the `--from` message id the\nhint names \u2014 that forwarding message carries the cross-chat access, and when\nseveral forwards arrive in one turn the CLI\'s trigger default would point at\nthe wrong one. `--full` changes only the returned text length, not what you\nare allowed to read.\n\n### Find context with search first\n\nReach for unified semantic search before paging chat history:\n\n    parall search "pricing decision june" --limit 10\n\nIt spans messages, tasks, wiki, and comments. Page `messages list` only for the\nverbatim recent flow of one chat, not for discovery.\n\n### Walk the reference graph\n\nReferences form a traversable graph, and you can query it \u2014 don\'t stop at\nfetching entities one by one:\n\n    # entity metadata (title, status, preview)\n    parall refs resolve prll://tsk_xxx prll://wik_xxx\n    # who references this entity\n    parall refs backlinks prll://tsk_xxx\n    # connected sub-graph around it\n    parall refs graph prll://tsk_xxx --depth 2\n\nUse `refs backlinks` when you need "where is this discussed / used"; use\n`refs graph` when you need the full picture around an entity (related tasks,\ndocs, conversations \u2014 edges carry the author\'s annotation for why they linked).\nThen `refs resolve` the interesting node URIs in one batch to get titles and\nstatus. `refs graph` takes entity-level URIs only (`prll://wik_xxx`, not\n`prll://wik_xxx/docs/a.md`). All results are filtered to what you can see.{{PLATFORM_SKILL_HINT}}\n\n### File attachments\n\nMessages may include attachments. They appear in events as:\n\n    [Attachment: prll://att_xxx | image/png | 1.2MB | screenshot.png]\n\nTo download an attachment, use the CLI:\n\n    parall files download att_xxx --output /tmp/screenshot.png\n\nTo send a file:\n\n    parall messages send prll://cht_xxx --file /tmp/output.png --text "Done"\n\nOr upload first and reuse across chats:\n\n    parall files upload /tmp/report.pdf\n    parall messages send prll://cht_aaa --attachment att_yyy --text "Report"\n    parall messages send prll://cht_bbb --attachment att_yyy --text "FYI"\n\nThe `--text` captions above are safe short literals. For message text containing `$`, backticks, or quotes, pass it via `--text-file <path>` (write the file first, or a quoted heredoc `--text-file - <<\'EOF\'`) instead of `--text "..."` \u2014 inside double quotes the shell turns `$1,000` into `,000` and executes `$(...)`.\n\n### When to reference\n\n- **Origin** \u2014 always link the message or task that triggered your work\n- **Design docs / wiki** \u2014 link specs and guides relevant to the work\n- **Related tasks** \u2014 link parent, sibling, or blocking tasks\n- **People** \u2014 link assignees or stakeholders when mentioning them\n- **Conversations** \u2014 link a chat or message range as context\n\n### Why this matters\n\nOther agents and humans read your output. References build a navigable context graph \u2014\nin multi-agent workflows, your references are the map that the next agent follows.';
 var BRIDGE_SKILL_HINTS = {
   SCHEDULES_SKILL_HINT: " (read the `parall-schedules` skill at .parall/skills/parall-schedules.md).",
   TASKS_SKILL_HINT: "\nDetails: read the `parall-tasks` skill at .parall/skills/parall-tasks.md and follow it.",
@@ -51379,15 +51379,6 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 var CAPABILITY_FEISHU_CLI = "feishu-cli";
-var CAPABILITY_SLACK_SEND = "slack-send";
-var CAPABILITY_WECHAT_SEND = "wechat-send";
-function channelCapabilityKeyFor(provider) {
-  if (provider === "slack")
-    return CAPABILITY_SLACK_SEND;
-  if (provider === "wechat")
-    return CAPABILITY_WECHAT_SEND;
-  return `${provider}-cli`;
-}
 var CHANNEL_POINTER_MAGIC = "parall channel capability pointer";
 function capabilityBinDir(stateDir) {
   return path.join(stateDir, "bin");
@@ -51468,213 +51459,18 @@ function buildErrorStepContent(message) {
   return { text: message, suppressed: false, status: "error" };
 }
 
-// ts/agent-core/dist/event-format.js
-var MESSAGE_REF_URI = "prll:\\/\\/msg_[A-Za-z0-9_-]+(?:\\/content\\?v=[1-9][0-9]{0,8}#t=[0-9]+-[0-9]+)?";
-var MESSAGE_RANGE_REF_URI = "prll:\\/\\/cht_[A-Za-z0-9_-]+#range=msg_[A-Za-z0-9_-]+,msg_[A-Za-z0-9_-]+";
-var REF_URI = `(?:${MESSAGE_REF_URI}|${MESSAGE_RANGE_REF_URI})`;
-var REF_TOKEN = `(?:${REF_URI}|\\[(?:[^\\[\\]]|\\[[^\\[\\]]*\\])*\\]\\(${REF_URI}\\)|<${REF_URI}>)`;
-var FORWARDED_REF_LINE = new RegExp(`^${REF_TOKEN}(?:\\s+${REF_TOKEN})*$`);
-function isForwardedMessageBody(body) {
-  const lines = body.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  return lines.length > 0 && lines.every((line) => FORWARDED_REF_LINE.test(line));
-}
+// ts/agent-core/dist/fork-prefix.js
 function sanitizeMeta(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/[[\]|]/g, " ").trim();
 }
-function formatApprovalDecisionReason(status, reason) {
-  const normalized = reason?.trim();
-  if (status !== "rejected" || !normalized)
-    return "";
-  return `Reason (JSON): ${JSON.stringify(normalized)}`;
-}
-function threadWatcherHint(threadRootId) {
-  return `[Hint: watcher \u2014 you were not addressed in this reply. Reply only if you add something new; otherwise run \`parall no-reply\`. If this thread is not relevant to you, or you have nothing more to contribute, run \`parall messages unwatch prll://${threadRootId}\` so later replies stop waking you.]`;
-}
-function buildEventBody(event) {
-  const lines = [];
-  if (event.type === "message") {
-    lines.push(`[Event: message.new]`);
-    const chatLabel = event.targetName ? `"${event.targetName}" (prll://${event.targetId})` : `prll://${event.targetId}`;
-    lines.push(`[Chat: ${chatLabel} | type: ${event.targetType ?? "unknown"}]`);
-    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push(`[Message ID: prll://${event.messageId}]`);
-    if (event.threadRootId) {
-      const threadMeta = [
-        `prll://${event.threadRootId}`,
-        event.threadReplyCount != null ? `${event.threadReplyCount} replies` : null,
-        event.threadUnreadCount != null && event.threadUnreadCount > 0 ? `${event.threadUnreadCount} unread` : null,
-        event.threadUnreadCount != null && event.threadUnreadCount > 0 && event.threadUnreadSince ? `since: prll://${event.threadUnreadSince}` : null
-      ].filter(Boolean).join(" | ");
-      lines.push(`[Thread: ${threadMeta}]`);
-    }
-    if (event.deliveryReason)
-      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
-    if (event.deliveryReason === "watcher" && event.threadRootId) {
-      lines.push(threadWatcherHint(sanitizeMeta(event.threadRootId)));
-    }
-    if (event.unreadCount != null && event.unreadCount > 1) {
-      const countStr = event.unreadCount >= 1e3 ? "999+" : String(event.unreadCount);
-      const sinceStr = event.unreadSince ? ` | since: prll://${event.unreadSince}` : "";
-      let line = `[Unread: ${countStr} messages${sinceStr}]`;
-      if (event.unreadCount > 50)
-        line += ` \u2014 fetch recent context with --limit, not all`;
-      lines.push(line);
-    }
-    if (event.noReply)
-      lines.push(`[Hint: no_reply]`);
-    if (isForwardedMessageBody(event.body)) {
-      lines.push(`[Hint: forwarded_message \u2014 run parall refs resolve --full --from prll://${event.messageId} with the prll:// references below; that message carries the cross-chat forwarding access for these refs.]`);
-    }
-    if (event.attachments?.length) {
-      for (const att of event.attachments) {
-        const sizeStr = att.fileSize >= 1048576 ? `${(att.fileSize / 1048576).toFixed(1)}MB` : `${Math.round(att.fileSize / 1024)}KB`;
-        lines.push(`[Attachment: prll://${att.id} | ${sanitizeMeta(att.mimeType)} | ${sizeStr} | ${sanitizeMeta(att.fileName)}]`);
-      }
-    }
-    lines.push("", event.body);
-  } else if (event.type === "task_comment") {
-    lines.push(`[Event: task.comment.created]`);
-    const taskLabel = event.targetName ? `${event.targetName} (prll://${event.targetId})` : `prll://${event.targetId}`;
-    lines.push(`[Task: ${taskLabel}]`);
-    if (event.deliveryReason)
-      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
-    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push(`[Comment ID: prll://${event.messageId}]`);
-    lines.push("", event.body);
-  } else if (event.type === "wiki_comment") {
-    lines.push(`[Event: wiki.comment.created]`);
-    const target = event.replyTargetUri ?? `prll://${event.targetId}`;
-    if (event.targetType === "changeset") {
-      lines.push(`[Wiki Changeset: ${target}]`);
-    } else {
-      lines.push(`[Wiki: ${event.targetName ? `${sanitizeMeta(event.targetName)} (${target})` : target}]`);
-    }
-    if (event.deliveryReason)
-      lines.push(`[Delivery: ${sanitizeMeta(event.deliveryReason)}]`);
-    lines.push(`[From: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push(`[Comment ID: prll://${event.messageId}]`);
-    lines.push("", event.body);
-  } else if (event.type === "approval") {
-    lines.push(`[Event: approval.decided]`);
-    lines.push(`[Approval: prll://${event.messageId}]`);
-    lines.push(`[Chat: prll://${event.targetId}]`);
-    lines.push(`[Decided by: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push("", event.body);
-  } else if (event.type === "schedule") {
-    lines.push(`[Event: schedule.fired]`);
-    lines.push(`[Schedule: prll://${event.targetId}]`);
-    lines.push(`[Run: prll://${event.messageId}]`);
-    if (event.scheduledFireAt)
-      lines.push(`[Scheduled at: ${sanitizeMeta(event.scheduledFireAt)}]`);
-    if (event.attachedUri)
-      lines.push(`[Attached: ${sanitizeMeta(event.attachedUri)}]`);
-    lines.push("", event.body);
-  } else if (event.type === "channel_message") {
-    lines.push(`[Event: channel.message]`);
-    const providerLabel = sanitizeMeta(event.channelProvider ?? "external IM");
-    const convType = sanitizeMeta(event.channelConversationType ?? "conversation");
-    const convId = event.channelExternalConversationId ? sanitizeMeta(event.channelExternalConversationId) : void 0;
-    const convName = event.channelExternalConversationName ? sanitizeMeta(event.channelExternalConversationName) : void 0;
-    const convLabel = convName ? `${convName} (${convId ? `${convId}, ` : ""}${convType})` : convId ? `${convId} (${convType})` : convType;
-    lines.push(`[Channel: ${providerLabel} | conversation: ${convLabel}]`);
-    lines.push(`[From: ${sanitizeMeta(event.senderName)} (external user, not a Parall member)]`);
-    if (event.channelExternalMessageId) {
-      lines.push(`[External message ID: ${sanitizeMeta(event.channelExternalMessageId)}]`);
-    }
-    lines.push(`[Audience: this conversation lives on ${providerLabel}, OUTSIDE Parall. Readers cannot open prll:// links, Parall cards, or internal attachments \u2014 never include them in replies. Write plain conversational text.]`);
-    lines.push("", event.body);
-  } else if (event.type === "external_trigger") {
-    lines.push(`[Event: external.trigger]`);
-    lines.push(`[Trigger: prll://${event.targetId}]`);
-    lines.push(`[Run: prll://${event.messageId}]`);
-    if (event.externalConnectionId) {
-      const label = event.externalConnectionDisplayName ? `${sanitizeMeta(event.externalConnectionDisplayName)} (prll://${event.externalConnectionId})` : `prll://${event.externalConnectionId}`;
-      lines.push(`[Connection: ${label}]`);
-    }
-    if (event.externalIngressEventId)
-      lines.push(`[Ingress: prll://${event.externalIngressEventId}]`);
-    if (event.attachedUri)
-      lines.push(`[Attached: ${sanitizeMeta(event.attachedUri)}]`);
-    if (event.externalConnectionSourceType) {
-      lines.push(`[Source: ${sanitizeMeta(event.externalConnectionSourceType)}]`);
-    }
-    if (event.externalIngressEventType) {
-      lines.push(`[External event: ${sanitizeMeta(event.externalIngressEventType)}]`);
-    }
-    lines.push("", event.body);
-  } else {
-    lines.push(`[Event: task.assigned]`);
-    const taskLabel = event.targetName ? `${event.targetName} (prll://${event.targetId})` : `prll://${event.targetId}`;
-    lines.push(`[Task: ${taskLabel}]`);
-    lines.push(`[Assigned by: ${event.senderName} (prll://${event.senderId})]`);
-    lines.push("", event.body);
-  }
-  return lines.join("\n") + buildSendMessageHint(event);
-}
-function buildEventBodyForForkResult(event) {
-  return buildEventBody(event).replace(/\n<system-reminder>[\s\S]*<\/system-reminder>$/, "");
+function eventBody(event) {
+  return event.frame ?? "";
 }
-function buildSendMessageHint(event) {
-  if (event.noReply)
-    return "";
-  if (event.type === "wiki_comment" && event.replyTargetUri) {
-    const where = event.targetType === "changeset" ? "this changeset comment" : "this wiki page";
-    return `
-<system-reminder>To reply on ${where}, run: \`parall comments add --target "${event.replyTargetUri}" --body "..."\` (read the thread first with \`parall comments list --target "${event.replyTargetUri}"\`). To message someone instead, use \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
-  }
-  if (event.targetId.startsWith("cht_")) {
-    if (event.threadRootId) {
-      return `
-<system-reminder>To reply in this thread, run \`parall messages send prll://${event.targetId} --thread-root-id ${sanitizeMeta(event.threadRootId)} --text-file - <<'EOF'\` \u2026 \`EOF\` \u2014 the quoted heredoc keeps \`$\`, backticks and apostrophes literal (plain \`--text "$1,000"\` sends \`,000\`). Your plain text output is not delivered to the chat.</system-reminder>`;
-    }
-    return `
-<system-reminder>To reply, run \`parall messages send prll://${event.targetId} --text-file - <<'EOF'\` \u2026 \`EOF\` \u2014 the quoted heredoc keeps \`$\`, backticks and apostrophes literal (plain \`--text "$1,000"\` sends \`,000\`). Your plain text output is not delivered to the chat.</system-reminder>`;
-  }
-  if (event.targetId.startsWith("tsk_")) {
-    return `
-<system-reminder>To respond, use the CLI: \`parall tasks update\` / \`parall tasks comments add\`. To message someone, use \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
-  }
-  if (event.targetId.startsWith("sch_")) {
-    return `
-<system-reminder>To communicate, use the CLI: \`parall messages send\` / \`parall dm\`. Your plain text output is not delivered.</system-reminder>`;
-  }
-  if (event.type === "channel_message") {
-    if (event.channelCliCapable) {
-      if (event.channelProvider === "slack") {
-        const channelArg = event.channelExternalConversationId ? ` --channel "${event.channelExternalConversationId}"` : " --channel <conversation id from this event>";
-        const replyTo = event.channelExternalMessageId ? ` --reply-to "${event.channelExternalMessageId}"` : "";
-        return `
-<system-reminder>To reply, use the platform verb: \`parall slack send${channelArg}${replyTo} --text <your reply>\`. In channels --reply-to is REQUIRED (the reply lands in that message's thread); in DMs it is optional (DMs are linear). \`parall slack send\` is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-      }
-      if (event.channelProvider === "wechat") {
-        const toArg = event.channelExternalConversationId ? ` --to "${event.channelExternalConversationId}"` : " --to <wxid from this event>";
-        const atArg = event.channelConversationType === "group" ? event.senderId && event.senderId !== "external" ? ` --at "${event.senderId}"` : " --at <wxid of the person you are answering>" : "";
-        const historyArg = event.channelExternalConversationId ? ` --conversation "${event.channelExternalConversationId}"` : " --conversation <wxid from this event>";
-        return `
-<system-reminder>Need earlier context? Run \`parall wechat history${historyArg}\`; history is not inserted automatically. To reply, use the platform verb: \`parall wechat send${toArg}${atArg} --text-file - <<'EOF'\` \u2026 \`EOF\` (or --text "<short text>" for simple literals \u2014 the quoted heredoc keeps $, backticks and apostrophes literal). In group chats, --at @-mentions the person you are answering. \`parall wechat send\` is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-      }
-      if (!event.channelProvider) {
-        return `
-<system-reminder>To reply, use the channel capability granted in your system prompt \u2014 for Feishu conversations that is \`lark-cli im\`, for Slack it is \`parall slack send\` (pass the message id from this event as --reply-to), for WeChat it is \`parall wechat send\`. That capability is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-      }
-      const convRef = event.channelExternalConversationId ? `chat_id "${event.channelExternalConversationId}"` : "the conversation id named in this event";
-      const threadAlt = event.channelExternalMessageId ? ` To reply threaded to this specific message, reference message_id "${event.channelExternalMessageId}".` : "";
-      return `
-<system-reminder>To reply, use the official Feishu CLI on your PATH: send a message to ${convRef} with \`lark-cli im\` (see \`lark-cli im --help\` for send syntax; auth is provisioned automatically).${threadAlt} lark-cli is the ONLY outbound path \u2014 your plain text output is NOT delivered to the external conversation.</system-reminder>`;
-    }
-    const platform = event.channelProvider ?? "the external platform";
-    return `
-<system-reminder>This message arrived from ${platform}, but outbound replies are currently disabled for this org (no channel capability granted). Do NOT attempt to reply on the external platform. If action is needed, surface it inside Parall (\`parall messages send\` / \`parall dm\`). Your plain text output is not delivered anywhere.</system-reminder>`;
-  }
-  if (event.type === "external_trigger" || event.targetId.startsWith("xtr_")) {
-    return `
-<system-reminder>This external trigger is incoming-only. Your plain text output is not sent back to the external provider. To communicate in Parall, use \`parall messages send\` / \`parall dm\`; provider-specific outbound actions require a separate capability.</system-reminder>`;
-  }
-  return "";
+function forkResultBody(event) {
+  return eventBody(event).replace(/\n\[Reminder[^\n]*\]$/, "");
 }
 function buildForkScopePrefix(event) {
-  const targetLabel = event.targetName ? `"${event.targetName}" (prll://${event.targetId})` : `prll://${event.targetId}`;
-  return `[Fork scope: You are a parallel worker forked from the main session to handle ${targetLabel}. The conversation history above belongs to the main session's in-progress dispatch \u2014 do NOT continue it or complete it, or produce external output (comments, messages) for work visible there. The main session owns its own output.
+  return `[Fork scope: You are a parallel worker forked from the main session to handle prll://${event.targetId}. The conversation history above belongs to the main session's in-progress dispatch \u2014 do NOT continue it or complete it, or produce external output (comments, messages) for work visible there. The main session owns its own output.
 
 Only act on the event below within your target scope. If your event reveals findings about the main session's work, report them in your summary \u2014 do not post them externally.
 
@@ -51703,6 +51499,26 @@ function buildForkResultPrefix(results) {
 
 // ts/agent-core/dist/gateway-base.js
 import * as os from "node:os";
+
+// ts/agent-core/dist/change-source.js
+var CHANGE_REASONS = /* @__PURE__ */ new Set([
+  "edited",
+  "deleted",
+  "unmentioned",
+  "mention",
+  "reaction"
+]);
+function splitChangeSource(sourceId) {
+  const i = sourceId.indexOf("~");
+  if (i <= 0)
+    return { messageId: sourceId };
+  const [reason] = sourceId.slice(i + 1).split("~");
+  if (!reason || !CHANGE_REASONS.has(reason))
+    return { messageId: sourceId };
+  return { messageId: sourceId.slice(0, i), reason };
+}
+
+// ts/agent-core/dist/gateway-base.js
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
 import { randomUUID } from "node:crypto";
@@ -51817,6 +51633,8 @@ var ENDPOINTS = {
   MESSAGE_WATCH: (id) => `${API_BASE}/messages/${id}/watch`,
   MESSAGE_WATCHERS: (id) => `${API_BASE}/messages/${id}/watchers`,
   MESSAGE_WATCHING: (id) => `${API_BASE}/messages/${id}/watching`,
+  /** Caller's attention levels across chats / threads / tasks. */
+  WATCHES: (orgId) => `${API_BASE}/orgs/${orgId}/watches`,
   MESSAGE_REACTIONS: (id) => `${API_BASE}/messages/${id}/reactions`,
   MESSAGE_REACTION: (id, emoji) => `${API_BASE}/messages/${id}/reactions/${encodeURIComponent(emoji)}`,
   // Upload (org-scoped)
@@ -51839,6 +51657,7 @@ var ENDPOINTS = {
   AGENT_ACTIVITY: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/activity`,
   AGENT_MONITOR: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/monitor`,
   AGENT_ME: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me`,
+  AGENT_REPLY_POLICY_CAPABILITY: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me/reply-policy-capability`,
   AGENT_NEW_SESSION: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/new-session`,
   AGENT_DEEP_RESET: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/deep-reset`,
   AGENT_SESSIONS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions`,
@@ -51875,6 +51694,7 @@ var ENDPOINTS = {
   MACHINE_AGENT_WORKSPACE_SETUP: (orgId, machineId, agentId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/agents/${agentId}/workspace/setup`,
   MACHINE_LLM_SOURCE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/llm-source`,
   MACHINE_PROVIDER_ENABLED: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/provider-enabled`,
+  MACHINE_MANAGED_BY: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/managed-by`,
   MACHINE_CAPABILITIES: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/capabilities`,
   MACHINE_RUNTIME_AUTH: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth`,
   MACHINE_KEYS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys`,
@@ -52355,8 +52175,22 @@ var ProjectTaskClient = class {
   async unsubscribeTaskMember(orgId, taskId, userId) {
     return this.request("DELETE", ENDPOINTS.TASK_SUBSCRIBER(orgId, taskId, userId));
   }
-  async watchThread(threadRootId) {
-    return this.request("POST", ENDPOINTS.MESSAGE_WATCH(threadRootId));
+  async watchThread(threadRootId, body) {
+    return this.request("POST", ENDPOINTS.MESSAGE_WATCH(threadRootId), body);
+  }
+  // ---- Attention settings (agent-attention-design.md §4) ----
+  /** The caller's watch rows: the setting per chat / thread. */
+  async listWatches(orgId) {
+    const res = await this.request("GET", ENDPOINTS.WATCHES(orgId));
+    return res.data;
+  }
+  /**
+   * Set the caller's setting on one target (prll://cht_ / msg_ root).
+   * Threads are watched first when not yet; chats require membership (404
+   * NOT_A_MEMBER otherwise). Tasks carry no setting (watch / unwatch only).
+   */
+  async setWatchLevel(orgId, body) {
+    return this.request("PUT", ENDPOINTS.WATCHES(orgId), body);
   }
   async unwatchThread(threadRootId) {
     return this.request("DELETE", ENDPOINTS.MESSAGE_WATCH(threadRootId));
@@ -53405,6 +53239,15 @@ var ParallClient = class _ParallClient extends AttachmentClient {
     const res = await this.request("GET", ENDPOINTS.APPROVALS_ACTIONS);
     return res.data;
   }
+  /**
+   * Action names plus the payload contract each documented action publishes
+   * (field names, types, and where a CAS base like expected_version is read
+   * from). Additive over getApprovableActions(): older servers omit
+   * `contracts`.
+   */
+  async getApprovableActionCatalog() {
+    return this.request("GET", ENDPOINTS.APPROVALS_ACTIONS);
+  }
   // ---- Agents (org-scoped) ----
   async createAgent(orgId, req, opts) {
     return this.request("POST", ENDPOINTS.AGENTS(orgId), req, void 0, false, opts);
@@ -53629,6 +53472,19 @@ var ParallClient = class _ParallClient extends AttachmentClient {
       provider_enabled: providerEnabled
     });
   }
+  /**
+   * Convert a member's personal device into an organization machine
+   * (PATCH /machines/{id}/managed-by). One-way and idempotent; org admins only
+   * (an admin-role agent qualifies). After conversion every org admin manages
+   * the machine and the registrant is just a member. 'member' is rejected —
+   * an org machine cannot become a personal device again. See
+   * docs/engineering-design/org-machine-assets-design.md §4.
+   */
+  async convertMachineToOrgManaged(orgId, machineId) {
+    return this.request("PATCH", ENDPOINTS.MACHINE_MANAGED_BY(orgId, machineId), {
+      managed_by: "org"
+    });
+  }
   /**
    * Replace the machine's capability set (admin). Primary use: healing a
    * machine that registered without `browser_provider` during the capability
@@ -53878,6 +53734,18 @@ var ParallClient = class _ParallClient extends AttachmentClient {
   async steerDispatch(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_STEER(orgId), req);
   }
+  /**
+   * Declare the runtime contract for this WS connection: the runtime runs
+   * what the server decides and takes the server-rendered wake frame from
+   * claim / steer responses instead of filtering and rendering locally.
+   * Bound to the connection's session id; re-declare on every hello.
+   * 409 STALE_WS_SESSION when the id is not the agent's current connection.
+   */
+  async declareReplyPolicyCapability(orgId, wsSessionId) {
+    await this.request("PUT", ENDPOINTS.AGENT_REPLY_POLICY_CAPABILITY(orgId), {
+      ws_session_id: wsSessionId
+    });
+  }
   /** Advance exact runtime-input lifecycle for members of an explicit lane. */
   async updateDispatchInputState(orgId, req) {
     return this.request("POST", ENDPOINTS.DISPATCH_INPUT_STATE(orgId), req);
@@ -55209,20 +55077,6 @@ function buildApiError(res, rawErrorBody) {
   return apiError;
 }
 
-// ts/sdk/dist/types.js
-var MENTION_ALL_USER_ID = "all";
-var MENTION_ALL_HUMANS_USER_ID = "allhuman";
-var MENTION_ALL_AGENTS_USER_ID = "allagent";
-function mentionTargetsUser(mentionUserId, userId, userType) {
-  if (mentionUserId === userId || mentionUserId === MENTION_ALL_USER_ID)
-    return true;
-  if (mentionUserId === MENTION_ALL_HUMANS_USER_ID)
-    return userType === "human";
-  if (mentionUserId === MENTION_ALL_AGENTS_USER_ID)
-    return userType === "agent";
-  return false;
-}
-
 // ts/sdk/dist/ws.js
 function isRetryableNetworkError(err) {
   return err instanceof Error && err.name === "ApiError" && "status" in err && err.status === 0;
@@ -55654,7 +55508,7 @@ var LaneLedger = class {
   get contextDir() {
     return this.opts.contextDir;
   }
-  /** Only chat message events ride the lane ledger; typed events stay on the legacy ack path. */
+  /** Chat message events ride (target, thread) lanes; typed events ride single-member dsp lanes (claimTyped). */
   handles(event) {
     return event.type === "message" && event.targetId.startsWith("cht_");
   }
@@ -55670,6 +55524,75 @@ var LaneLedger = class {
   laneContextPath(lane) {
     return laneContextFilePath(this.opts.contextDir, lane.targetUri, lane.threadRootId);
   }
+  /**
+   * Whether the server already rendered this message into a frame the model
+   * saw on its live lane. The row is folded there and resolves with that
+   * lane's turn — a local copy has nothing left to deliver.
+   */
+  seenInFrame(targetId, threadRootId, messageId) {
+    const lane = this.lanes.get(laneKeyForTarget(`prll://${targetId}`, threadRootId));
+    return lane?.seen.has(messageId) ?? false;
+  }
+  /**
+   * Hand the pending frame to the caller (once) with the members it covers
+   * and what the claim said about the wake, and record those members as
+   * seen. Absent frame ⇒ nothing new to render (every member already seen).
+   */
+  takeFrame(lane) {
+    const frame = lane.frame;
+    const ids = lane.framed;
+    for (const id of ids)
+      lane.seen.add(id);
+    lane.frame = void 0;
+    lane.framed = [];
+    const { input, noReply, attachments } = lane;
+    lane.input = void 0;
+    lane.noReply = void 0;
+    lane.attachments = void 0;
+    return { frame, ids, input, noReply, attachments };
+  }
+  /** Record what the claim response said about the wake alongside its frame. */
+  recordWake(lane, res) {
+    if (res.input)
+      lane.input = res.input;
+    if (res.no_reply != null)
+      lane.noReply = res.no_reply;
+    if (res.attachments?.length) {
+      lane.attachments = res.attachments.map((a) => ({
+        id: a.id,
+        fileName: a.file_name ?? "",
+        fileSize: a.file_size ?? 0,
+        mimeType: a.mime_type ?? ""
+      }));
+    }
+  }
+  /** The injection landed: the model has seen these members. */
+  markSeen(event, ids) {
+    const lane = this.lanes.get(this.laneKeyFor(event));
+    if (!lane)
+      return;
+    for (const id of ids)
+      lane.seen.add(id);
+  }
+  /**
+   * The injection did not land (turn already over, process gone): keep the
+   * server's increment as the lane's pending frame so the buffered copy's
+   * drain renders it as its own turn instead of skipping it as seen.
+   */
+  deferFrame(event, frame, ids) {
+    const lane = this.lanes.get(this.laneKeyFor(event));
+    if (!lane)
+      return;
+    this.recordFrame(lane, frame, ids);
+  }
+  recordFrame(lane, frame, ids) {
+    if (!frame)
+      return;
+    lane.frame = lane.frame ? `${lane.frame}
+
+${frame}` : frame;
+    lane.framed.push(...ids);
+  }
   /**
    * Claim (or reuse) the lane for a group of same-lane message events and
    * fold every group member into it. Returns 'foreign' when a healthy
@@ -55719,11 +55642,15 @@ var LaneLedger = class {
         threadRootId: trigger.threadRootId,
         coverageMode: actualCoverage,
         folded: /* @__PURE__ */ new Map(),
+        framed: [],
+        seen: /* @__PURE__ */ new Set(),
         ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
       };
       for (const ev of res.events ?? []) {
         lane.folded.set(ev.source_id, ev.id);
       }
+      this.recordFrame(lane, res.frame, (res.events ?? []).map((ev) => ev.source_id));
+      this.recordWake(lane, res);
       this.lanes.set(laneKey, lane);
     }
     for (const ev of events) {
@@ -55737,6 +55664,7 @@ var LaneLedger = class {
           ...ev.dispatchEventId ? { dispatch_event_id: ev.dispatchEventId } : { source_type: "message", source_id: ev.messageId }
         });
         lane.folded.set(ev.messageId, res.dispatch_event_id);
+        this.recordFrame(lane, res.frame, [ev.messageId]);
       } catch (err) {
         if (isStaleLane(err)) {
           this.lanes.delete(laneKey);
@@ -55760,8 +55688,13 @@ var LaneLedger = class {
     const lane = this.lanes.get(laneKey);
     if (!lane)
       return null;
+    if (lane.seen.has(event.messageId))
+      return null;
     if (lane.folded.has(event.messageId)) {
-      return { inputLifecycle: this.inputLifecycle(lane, [event]) };
+      return {
+        inputLifecycle: this.inputLifecycleFor(lane, [event.messageId]),
+        covered: [event.messageId]
+      };
     }
     try {
       const res = await this.opts.client.steerDispatch(this.opts.orgId, {
@@ -55771,7 +55704,12 @@ var LaneLedger = class {
         ...event.dispatchEventId ? { dispatch_event_id: event.dispatchEventId } : { source_type: "message", source_id: event.messageId }
       });
       lane.folded.set(event.messageId, res.dispatch_event_id);
-      return { inputLifecycle: this.inputLifecycle(lane, [event]) };
+      const covered = [event.messageId];
+      return {
+        inputLifecycle: this.inputLifecycleFor(lane, covered),
+        frame: res.frame,
+        covered
+      };
     } catch (err) {
       if (isStaleLane(err)) {
         this.lanes.delete(laneKey);
@@ -55786,10 +55724,18 @@ var LaneLedger = class {
    * batched prompt covers every WorkItem represented in that single frame.
    */
   inputLifecycle(lane, events) {
+    return this.inputLifecycleFor(lane, events.map((event) => event.messageId));
+  }
+  /**
+   * Exact lifecycle over a set of folded members by message id — the set a
+   * prompt or injection actually delivers (frame coverage ∪ buffered group).
+   */
+  inputLifecycleFor(lane, messageIds) {
     if (lane.coverageMode !== "explicit")
       return void 0;
-    const dispatchEventIds = events.map((event) => lane.folded.get(event.messageId)).filter((id) => Boolean(id));
-    if (dispatchEventIds.length !== events.length) {
+    const unique = [...new Set(messageIds)];
+    const dispatchEventIds = unique.map((messageId) => lane.folded.get(messageId)).filter((id) => Boolean(id));
+    if (dispatchEventIds.length !== unique.length) {
       throw new Error(`explicit lane ${lane.lane} is missing a folded WorkItem mapping`);
     }
     return {
@@ -55987,10 +55933,12 @@ var LaneLedger = class {
     return this.lanes.size;
   }
   /**
-   * Claim the single-member lane of one typed WorkItem (resource = dsp:<id>),
-   * by WorkItem id or by source identity (the live task.assigned event has no
-   * WorkItem id). Returns null when a healthy incumbent (another pod) holds
-   * it or the WorkItem is already resolved — the caller must skip processing.
+   * Claim the single-member lane of one typed WorkItem (resource = dsp:<id>)
+   * by WorkItem id. The server renders the wake frame on claim (or resolves
+   * the item as stale and answers `claimed: false, reason: "stale"`).
+   * Returns null when a healthy incumbent (another pod) holds it, the
+   * WorkItem is already resolved, or the server found nothing to wake for
+   * — the caller must skip processing.
    */
   async claimTyped(ref) {
     let res;
@@ -56005,8 +55953,15 @@ var LaneLedger = class {
         throw new LedgerUnsupportedError("claim endpoint unavailable");
       throw err;
     }
-    if (!res.claimed || !res.lane || !res.events?.length)
+    if (!res.claimed || !res.lane || !res.events?.length) {
+      if (res.reason === "stale") {
+        this.opts.log?.info(`typed dispatch ${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`} resolved by the server as stale (${res.stale_reason ?? "unspecified"})`);
+      } else if (res.claimed && res.lane) {
+        await this.opts.client.releaseDispatchLane(this.opts.orgId, res.lane).catch(() => {
+        });
+      }
       return null;
+    }
     const workItem = res.events[0];
     const targetUri = `dsp:${workItem.id}`;
     const leaseUntilMs = Date.parse(res.lease_until ?? "");
@@ -56016,9 +55971,13 @@ var LaneLedger = class {
       targetUri,
       coverageMode: "implicit",
       folded: /* @__PURE__ */ new Map([[workItem.source_id, workItem.id]]),
+      framed: [],
+      seen: /* @__PURE__ */ new Set(),
       typedDispatchEventId: workItem.id,
       ...Number.isNaN(leaseUntilMs) ? {} : { leaseUntilMs, leaseTtlMs: Math.max(leaseUntilMs - Date.now(), 6e4) }
     };
+    this.recordFrame(lane, res.frame, [workItem.source_id]);
+    this.recordWake(lane, res);
     this.lanes.set(lane.laneKey, lane);
     return lane;
   }
@@ -56061,6 +56020,19 @@ function shiftMainBufferGroup(host, groupKey, preserveInjectedFrameBoundary) {
   }
   return events;
 }
+function applyWake(event, wake) {
+  if (wake.frame)
+    event.frame = wake.frame;
+  if (wake.input) {
+    event.input = wake.input;
+    if (wake.input.sender_id)
+      event.senderId = wake.input.sender_id;
+  }
+  if (wake.noReply != null)
+    event.noReply = wake.noReply;
+  if (wake.attachments?.length)
+    event.attachments = wake.attachments;
+}
 function hasUninjectedSameLaneEventAhead(host, event) {
   const eventIndex = host.dispatchState.mainBuffer.lastIndexOf(event);
   if (eventIndex <= 0)
@@ -56078,10 +56050,17 @@ async function steerLaneMessage(host, event) {
   const folded = await ledger.steerLive(event);
   if (!folded)
     return;
-  const injected = await adapter.enqueueDuringDispatch(opts.runtimeKey, buildEventBody(event), folded.inputLifecycle);
+  if (!folded.frame)
+    return;
+  event.frame = folded.frame;
+  const injected = await adapter.enqueueDuringDispatch(opts.runtimeKey, eventBody(event), folded.inputLifecycle);
   if (injected) {
     host.injectedMainBufferEvents.add(event);
+    ledger.markSeen(event, folded.covered);
     opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
+  } else if (folded.frame) {
+    ledger.deferFrame(event, folded.frame, folded.covered);
+    opts.log?.info(`steer folded but not injected for ${event.messageId} \u2014 frame deferred to the drain`);
   }
 }
 async function dispatchLaneGroup(host, opts) {
@@ -56094,18 +56073,9 @@ async function dispatchLaneGroup(host, opts) {
     if (!(err instanceof LedgerUnsupportedError))
       throw err;
     host.disableLedger("claim endpoint missing");
-    await host.emitDispatchReceived(event);
-    const dispatched2 = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
-    if (!dispatched2)
-      return "shutdown";
-    for (const ev of opts.events) {
-      host.opts.client.ackDispatch(host.opts.config.org_id, {
-        source_type: ev.ackSourceType ?? "message",
-        source_id: ev.ackSourceId ?? ev.messageId
-      }).catch(() => {
-      });
-    }
-    return "dispatched";
+    for (const ev of opts.events)
+      host.dispatchedMessages.delete(ev.messageId);
+    return "foreign";
   }
   if (!lane) {
     for (const ev of opts.events) {
@@ -56113,11 +56083,32 @@ async function dispatchLaneGroup(host, opts) {
     }
     return "foreign";
   }
+  const pending = ledger.takeFrame(lane);
+  const frame = pending.frame;
+  if (!frame && opts.events.every((ev) => lane.seen.has(ev.messageId))) {
+    host.opts.log?.info(`lane group for ${event.messageId} already rendered by the server frame \u2014 no turn`);
+    const pendingInjections2 = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
+    await ledger.completeIfIdle(lane.laneKey, pendingInjections2 || opts.hasMoreLocal());
+    return "dispatched";
+  }
+  if (!frame) {
+    host.opts.log?.warn(`lane group for ${event.messageId} claimed without a frame \u2014 releasing the members instead of running`);
+    for (const ev of opts.events)
+      host.dispatchedMessages.delete(ev.messageId);
+    await ledger.release(lane.laneKey).catch(() => {
+    });
+    return "foreign";
+  }
+  applyWake(event, pending);
   host.noteSessionLane(opts.sessionKey, lane.laneKey);
   let dispatched = false;
   try {
-    const inputLifecycle = ledger.inputLifecycle(lane, [...opts.earlier, event]);
-    dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText, inputLifecycle);
+    const inputLifecycle = ledger.inputLifecycleFor(lane, [
+      ...opts.earlier.map((ev) => ev.messageId),
+      event.messageId,
+      ...frame ? pending.ids : []
+    ]);
+    dispatched = await host.runDispatch(event, opts.sessionKey, opts.bodyPrefix + eventBody(event), opts.earlier, opts.captureText, inputLifecycle);
   } catch (err) {
     host.noteSessionLane(opts.sessionKey, null);
     await ledger.release(lane.laneKey).catch(() => {
@@ -56185,50 +56176,16 @@ async function resolveDispatchByID(host, dispatchEventId, lane) {
     return "failed";
   }
 }
-function clearTypedDedupeForEvent(host, event) {
-  const sourceId = event.ackSourceId;
-  if (!sourceId)
-    return;
-  switch (event.ackSourceType) {
-    case "task_activity": {
-      const prefix = `${event.targetId}:`;
-      for (const key of host.dispatchedTasks) {
-        if (key.startsWith(prefix))
-          host.dispatchedTasks.delete(key);
-      }
-      break;
-    }
-    case "comment":
-      host.dispatchedTasks.delete(`comment:${sourceId}`);
-      break;
-    case "schedule_run":
-      host.dispatchedTasks.delete(`schedule_run:${sourceId}`);
-      break;
-    case "external_trigger_run":
-      host.dispatchedTasks.delete(`external_trigger_run:${sourceId}`);
-      break;
-    case "channel_message":
-      host.dispatchedMessages.delete(`channel_message:${sourceId}`);
-      break;
-    case "approval":
-      host.dispatchedTasks.delete(`approval:${sourceId}`);
-      break;
-  }
-}
 async function settleDrainedTypedGroup(host, events, ids, turnErrored) {
   if (turnErrored) {
     host.opts.log?.info(`buffered typed turn for ${events[events.length - 1]?.messageId} surfaced a runtime error \u2014 leaving for re-drive`);
-    for (const event of events)
-      clearTypedDedupeForEvent(host, event);
     return;
   }
   const legacyAckFrom = async (start) => {
-    for (const [j, id] of ids.slice(start).entries()) {
+    for (const id of ids.slice(start)) {
       try {
         await host.opts.client.ackDispatchByID(host.opts.config.org_id, id);
       } catch {
-      } finally {
-        clearTypedDedupeForEvent(host, events[start + j]);
       }
     }
   };
@@ -56244,7 +56201,6 @@ async function settleDrainedTypedGroup(host, events, ids, turnErrored) {
       await legacyAckFrom(i);
       return;
     }
-    clearTypedDedupeForEvent(host, events[i]);
   }
 }
 var TYPED_BACKOFF_BASE_MS = 2e3;
@@ -56280,18 +56236,8 @@ async function consumeTypedDispatch(host, ref, run, hooks) {
     }
     host.typedRedriveBackoff.set(backoffKey, { failures, until: Date.now() + backoffMs });
   };
-  const runLegacy = async () => {
-    let acked = false;
-    try {
-      if (await run(ref.dispatchEventId)) {
-        acked = settleAck(await hooks.legacyAck(ref.dispatchEventId));
-      }
-    } finally {
-      settle(acked);
-    }
-  };
   if (!host.laneLedger || host.ledgerDisabled) {
-    await runLegacy();
+    host.opts.log?.info(`typed dispatch ${backoffKey} skipped \u2014 the server renders no wake frame`);
     return;
   }
   let lane;
@@ -56300,7 +56246,6 @@ async function consumeTypedDispatch(host, ref, run, hooks) {
   } catch (err) {
     if (err instanceof LedgerUnsupportedError) {
       host.disableLedger("claim endpoint missing");
-      await runLegacy();
       return;
     }
     throw err;
@@ -56312,7 +56257,7 @@ async function consumeTypedDispatch(host, ref, run, hooks) {
   let resolved = false;
   let viaLegacyAck = false;
   try {
-    if (await run(lane.typedDispatchEventId)) {
+    if (await run(lane)) {
       if (host.typedByIdCompleteUnsupported || !lane.typedDispatchEventId) {
         viaLegacyAck = true;
         resolved = settleAck(await hooks.legacyAck(lane.typedDispatchEventId));
@@ -56324,13 +56269,9 @@ async function consumeTypedDispatch(host, ref, run, hooks) {
           viaLegacyAck = true;
           resolved = settleAck(await hooks.legacyAck(lane.typedDispatchEventId));
         } else if (outcome === "stale") {
-          hooks.clearDedupe?.();
           resolved = true;
         } else {
           resolved = outcome === "ok";
-          if (!resolved) {
-            hooks.clearDedupe?.();
-          }
         }
       }
     }
@@ -56349,56 +56290,27 @@ async function consumeMessageWorkItem(host, item) {
     return;
   if (!host.tryClaimMessage(item.source_id))
     return;
-  if (host.dispatchState.mainBuffer.some((event) => event.messageId === item.source_id))
+  if (host.dispatchState.mainBuffer.some((event2) => event2.messageId === item.source_id))
     return;
-  const ackItem = () => {
-    if (host.laneLedger && !host.ledgerDisabled && !host.typedByIdCompleteUnsupported) {
-      void resolveDispatchByID(host, item.id).then((outcome) => {
-        if (outcome === "unsupported") {
-          host.typedByIdCompleteUnsupported = true;
-          host.opts.client.ackDispatchByID(host.opts.config.org_id, item.id).catch(() => {
-          });
-        }
-      });
-      return;
-    }
-    host.opts.client.ackDispatchByID(host.opts.config.org_id, item.id).catch(() => {
-    });
-  };
-  let msg = null;
-  try {
-    msg = await host.opts.client.getMessage(item.source_id);
-  } catch (err) {
-    const status = err?.status;
-    if (status !== 404) {
-      host.opts.log?.warn(`message fetch failed for ${item.source_id}, leaving pending: ${String(err)}`);
-      host.dispatchedMessages.delete(item.source_id);
-      return;
-    }
-  }
-  if (!msg || msg.sender_id === host.opts.agentUserId) {
-    host.dispatchedMessages.delete(item.source_id);
-    ackItem();
-    return;
-  }
-  const decision = await host.buildMessageDispatchDecision(item.chat_id, msg);
-  if (decision.action === "retry") {
-    host.dispatchedMessages.delete(item.source_id);
-    return;
-  }
-  if (decision.action === "skip") {
-    host.dispatchedMessages.delete(item.source_id);
-    ackItem();
+  if (host.laneLedger && !host.ledgerDisabled && host.laneLedger.seenInFrame(item.chat_id, item.thread_root_id ?? void 0, item.source_id)) {
     return;
   }
-  decision.event.dispatchEventId = item.id;
-  const laneResolved = host.usesLaneLedger(decision.event);
+  const change = splitChangeSource(item.source_id);
+  const event = {
+    type: "message",
+    targetId: item.chat_id,
+    targetType: "chat",
+    senderId: item.actor_id ?? "",
+    messageId: item.source_id,
+    threadRootId: item.thread_root_id ?? void 0,
+    deliveryReason: item.delivery_reason ?? change.reason ?? void 0,
+    ackSourceType: "message",
+    ackSourceId: item.source_id,
+    dispatchEventId: item.id
+  };
   try {
-    const dispatched = await host.handleInboundEvent(decision.event);
-    if (dispatched) {
-      if (!laneResolved)
-        ackItem();
-    } else {
+    const dispatched = await host.handleInboundEvent(event);
+    if (!dispatched) {
       host.dispatchedMessages.delete(item.source_id);
     }
   } catch (err) {
@@ -57587,6 +57499,16 @@ function createOtelLogger(layer, prefix) {
 
 // ts/agent-core/dist/gateway-base.js
 var LIVE_SESSION_STATUSES = /* @__PURE__ */ new Set(["open", "active", "idle"]);
+var TYPED_EVENT_KINDS = {
+  task_assign: { type: "task", ackSourceType: "task_activity" },
+  task_update: { type: "task", ackSourceType: "task_activity" },
+  task_comment: { type: "task_comment", ackSourceType: "comment" },
+  wiki_comment: { type: "wiki_comment", ackSourceType: "comment" },
+  "schedule.fire": { type: "schedule", ackSourceType: "schedule_run" },
+  external_trigger: { type: "external_trigger", ackSourceType: "external_trigger_run" },
+  channel_message: { type: "channel_message", ackSourceType: "channel_message" },
+  approval_decided: { type: "approval", ackSourceType: "approval" }
+};
 function parseShutdownDeadlineMs(raw) {
   if (!raw)
     return void 0;
@@ -57620,6 +57542,9 @@ function inputStepIdempotencyKey(event) {
   return randomUUID();
 }
 function resolveStepTarget(event) {
+  if (event.input?.step_target) {
+    return { target_type: event.input.step_target.type, target_id: event.input.step_target.id };
+  }
   if (event.type === "task" || event.targetId.startsWith("tsk_")) {
     return { target_type: "task", target_id: event.targetId };
   }
@@ -57640,48 +57565,63 @@ function resolveStepTarget(event) {
   }
   return { target_type: "", target_id: event.targetId || void 0 };
 }
-function parseWikiCommentTarget(targetUri) {
-  const routingKey = targetUri.replace(/^prll:\/\//, "");
-  const entityId = routingKey.match(/^([^/?#]+)/)?.[1] ?? routingKey;
-  const targetType = entityId.startsWith("wcs_") ? "changeset" : "wiki";
-  let label = entityId;
-  if (targetType === "wiki") {
-    const pathMatch = routingKey.slice(entityId.length).match(/^\/([^?#]+)/);
-    if (pathMatch) {
-      try {
-        label = decodeURIComponent(pathMatch[1]);
-      } catch {
-        label = pathMatch[1];
-      }
-    }
+function inputTriggerTypeFor(type) {
+  switch (type) {
+    case "task":
+      return "task_assign";
+    case "task_comment":
+      return "task_comment";
+    case "wiki_comment":
+      return "wiki_comment";
+    case "schedule":
+      return "schedule_fire";
+    case "external_trigger":
+      return "external_trigger";
+    case "channel_message":
+      return "channel_message";
+    case "approval":
+      return "approval_decided";
+    default:
+      return "mention";
+  }
+}
+function inputTriggerRef(event) {
+  const sourceId = event.ackSourceId ?? event.messageId;
+  switch (event.type) {
+    case "task":
+      return { task_id: event.targetId };
+    case "task_comment":
+      return { comment_id: sourceId, task_id: event.targetId };
+    case "wiki_comment":
+      return { comment_id: sourceId, target_uri: `prll://${event.targetId}` };
+    case "schedule":
+      return { schedule_id: event.targetId, run_id: sourceId };
+    case "external_trigger":
+      return { trigger_id: event.targetId, run_id: sourceId };
+    case "channel_message":
+      return { conversation_id: event.targetId, channel_message_id: sourceId };
+    case "approval":
+      return { approval_id: sourceId };
+    default:
+      return {
+        message_id: splitChangeSource(event.messageId).messageId,
+        // Thread context for the session→chat backlink: a thread reply can
+        // only be navigated to with its thread root.
+        ...event.threadRootId ? { thread_root_id: event.threadRootId } : {}
+      };
   }
-  return { routingKey, label, targetType };
-}
-async function fetchAllChats(client, orgId, chatInfoMap) {
-  let cursor;
-  let total = 0;
-  do {
-    const res = await client.getChats(orgId, { limit: 100, cursor });
-    for (const chat of res.data) {
-      chatInfoMap.set(chat.id, {
-        type: chat.type,
-        name: chat.name ?? null,
-        agentRoutingMode: chat.agent_routing_mode
-      });
-    }
-    total += res.data.length;
-    cursor = res.has_more ? res.next_cursor : void 0;
-  } while (cursor);
-  return total;
 }
 var ParallAgentGateway = class {
   opts;
-  chatInfoMap = /* @__PURE__ */ new Map();
-  dispatchedTasks = /* @__PURE__ */ new Set();
-  // connection id → provider alias, for channel_message prompt labeling
-  // (stable mapping; avoids one connection fetch per inbound message).
-  channelConnectionProviders = /* @__PURE__ */ new Map();
+  // In-process in-flight guard for message WorkItems (see LaneFlowHost).
   dispatchedMessages = /* @__PURE__ */ new Set();
+  /**
+   * Consumption fence: no WorkItem is claimed before this connection's
+   * runtime contract is declared (handleHello). A claim made before the
+   * declaration would get no frame — and a frameless claim has nothing to
+   * run. Open until the first hello starts a declaration.
+   */
+  contractReady = Promise.resolve();
   injectedMainBufferEvents = /* @__PURE__ */ new WeakSet();
   // Per-WorkItem failure backoff for typed dispatch consumption — see
   // LaneFlowHost.typedRedriveBackoff in gateway-lane-flow.ts.
@@ -57793,29 +57733,6 @@ var ParallAgentGateway = class {
     ws.on("hello", async (data) => {
       await this.handleHello(data);
     });
-    ws.on("chat.update", (data) => {
-      const changes = data.changes;
-      if (!changes)
-        return;
-      const existing = this.chatInfoMap.get(data.chat_id);
-      if (existing) {
-        this.chatInfoMap.set(data.chat_id, {
-          ...existing,
-          ...typeof changes.type === "string" ? { type: changes.type } : {},
-          ...typeof changes.name === "string" ? { name: changes.name } : {},
-          ...typeof changes.agent_routing_mode === "string" ? { agentRoutingMode: changes.agent_routing_mode } : {}
-        });
-      } else if (typeof changes.type === "string") {
-        this.chatInfoMap.set(data.chat_id, {
-          type: changes.type,
-          name: typeof changes.name === "string" ? changes.name : null,
-          agentRoutingMode: typeof changes.agent_routing_mode === "string" ? changes.agent_routing_mode : "passive"
-        });
-      }
-    });
-    ws.on("message.new", async (data) => {
-      await this.handleMessage(data);
-    });
     ws.on("agent_config.update", async (data) => {
       this.opts.log?.info(`config update notification (version=${data.version})`);
       try {
@@ -57843,135 +57760,11 @@ var ParallAgentGateway = class {
       this.opts.log?.warn(`recovery.overflow \u2014 triggering full catch-up`);
       this.catchUpFromDispatch().catch((err) => this.opts.log?.warn(`overflow catch-up failed: ${String(err)}`));
     });
-    ws.on("task.assigned", async (data) => {
-      if (data.assignee_id !== this.opts.agentUserId)
-        return;
-      if (data.status !== "todo" && data.status !== "in_progress")
-        return;
+    ws.on("dispatch.new", async (data) => {
       try {
-        await this.consumeTypedDispatch(data.dispatch_event_id ? { dispatchEventId: data.dispatch_event_id } : { sourceType: "task_activity", sourceId: data.id }, (dispatchEventId) => this.handleTaskAssignment(data, data.id, dispatchEventId), {
-          legacyAck: (dispatchEventId) => {
-            if (dispatchEventId) {
-              return this.ackDispatchEvent(dispatchEventId, () => {
-                this.dispatchedTasks.delete(`${data.id}:${data.updated_at}`);
-              });
-            }
-            return this.opts.client.ackDispatch(this.opts.config.org_id, {
-              source_type: "task_activity",
-              source_id: data.id
-            }).then(() => true, (err) => {
-              this.dispatchedTasks.delete(`${data.id}:${data.updated_at}`);
-              this.opts.log?.warn(`dispatch ack failed for task ${data.id}, releasing for re-drive: ${String(err)}`);
-              return false;
-            });
-          },
-          clearDedupe: () => this.dispatchedTasks.delete(`${data.id}:${data.updated_at}`)
-        });
+        await this.consumeWorkItem(data);
       } catch (err) {
-        this.opts.log?.error(`task dispatch failed for ${data.id}: ${String(err)}`);
-      }
-    });
-    ws.on("dispatch.new", async (data) => {
-      if (data.event_type !== "message" && this.isBufferedTypedWorkItem(data.id)) {
-        this.opts.log?.info(`typed dispatch ${data.id} already buffered for the drain \u2014 skipping re-claim`);
-        return;
-      }
-      if (data.event_type === "task_assign") {
-        if (!data.task_id)
-          return;
-        try {
-          await this.handleTaskAssignmentRedrive(data);
-        } catch (err) {
-          this.opts.log?.error(`task assignment re-drive failed for ${data.task_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "task_comment") {
-        if (!data.source_id || !data.task_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.handleTaskComment(data.source_id, data.task_id ?? "", data.actor_id, data.delivery_reason, dispatchEventId), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`task comment dispatch failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "wiki_comment") {
-        if (!data.source_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.handleWikiComment(data.source_id, data.actor_id, data.delivery_reason, dispatchEventId), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`wiki comment dispatch failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "task_update") {
-        if (!data.task_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.handleTaskDispatch(data.task_id ?? "", data.source_id ?? data.task_id ?? "", {
-            allowCreator: true,
-            dispatchEventId
-          }), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`task update dispatch failed for ${data.task_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "schedule.fire") {
-        if (!data.source_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.fetchAndHandleScheduleFire(data.source_id, data.actor_id, dispatchEventId), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`schedule fire dispatch failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "external_trigger") {
-        if (!data.source_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.fetchAndHandleExternalTriggerRun(data.source_id, dispatchEventId), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`external trigger dispatch failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "channel_message") {
-        if (!data.source_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.fetchAndHandleChannelMessage(data.source_id, dispatchEventId), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`channel message dispatch failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "approval_decided") {
-        if (!data.source_id)
-          return;
-        try {
-          await this.consumeTypedDispatch({ dispatchEventId: data.id }, (dispatchEventId) => this.fetchAndHandleApprovalDecided(data.source_id, data.actor_id, data.chat_id ?? null, dispatchEventId), {
-            legacyAck: () => this.ackDispatchEvent(data.id, () => this.clearTypedDispatchDedupe(data)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(data)
-          });
-        } catch (err) {
-          this.opts.log?.error(`approval decided dispatch failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type === "message" && this.laneLedger && data.source_id && data.chat_id) {
-        try {
-          await this.handleMessageRedrive(data);
-        } catch (err) {
-          this.opts.log?.error(`message re-drive failed for ${data.source_id}: ${String(err)}`);
-        }
-      } else if (data.event_type !== "message") {
-        this.opts.log?.info(`dispatch.new with unhandled event_type=${String(data.event_type)} (id=${data.id}) \u2014 no-op`);
+        this.opts.log?.error(`dispatch ${data.id} (${String(data.event_type)}) failed: ${String(err)}`);
       }
     });
     this.opts.log?.info(`connecting to ${this.opts.connectionLabel ?? "Parall WS"}...`);
@@ -58156,44 +57949,6 @@ var ParallAgentGateway = class {
   isTypedEventBuffered(event) {
     return this.isBufferedTypedWorkItem(event.dispatchEventId);
   }
-  // PARITY: this switch and gateway-lane-flow's clearTypedDedupeForEvent must
-  // handle the same typed source families — extend BOTH when adding a typed
-  // event type (same dedupe entries, keyed from different event shapes).
-  clearTypedDispatchDedupe(item) {
-    switch (item.event_type) {
-      case "task_assign":
-      case "task_update":
-        if (item.task_id) {
-          const prefix = `${item.task_id}:`;
-          for (const key of this.dispatchedTasks) {
-            if (key.startsWith(prefix))
-              this.dispatchedTasks.delete(key);
-          }
-        }
-        break;
-      case "task_comment":
-      case "wiki_comment":
-        if (item.source_id)
-          this.dispatchedTasks.delete(`comment:${item.source_id}`);
-        break;
-      case "schedule.fire":
-        if (item.source_id)
-          this.dispatchedTasks.delete(`schedule_run:${item.source_id}`);
-        break;
-      case "external_trigger":
-        if (item.source_id)
-          this.dispatchedTasks.delete(`external_trigger_run:${item.source_id}`);
-        break;
-      case "channel_message":
-        if (item.source_id)
-          this.dispatchedMessages.delete(`channel_message:${item.source_id}`);
-        break;
-      case "approval_decided":
-        if (item.source_id)
-          this.dispatchedTasks.delete(`approval:${item.source_id}`);
-        break;
-    }
-  }
   buildDispatchContext(event, sessionKey) {
     const binding = this.sessionBindings.get(sessionKey);
     return {
@@ -58206,7 +57961,7 @@ var ParallAgentGateway = class {
       runtimeKey: this.opts.runtimeKey,
       sessionId: binding?.agentSessionId,
       chatId: event.type === "message" || event.type === "approval" ? event.targetId : void 0,
-      triggerMessageId: event.messageId,
+      triggerMessageId: splitChangeSource(event.messageId).messageId,
       noReply: event.noReply ?? false,
       contextFilePath: this.opts.contextFilePathForSession?.(sessionKey),
       stepIdFilePath: this.opts.stepIdFilePathForSession?.(sessionKey),
@@ -58220,35 +57975,24 @@ var ParallAgentGateway = class {
   }
   async createInputStep(sessionId, event) {
     const target = resolveStepTarget(event);
+    const input = event.input;
     await this.stepPersister.persist(sessionId, "input", {
       step_type: "input",
       target_type: target.target_type,
       target_id: target.target_id,
       idempotency_key: inputStepIdempotencyKey(event),
       content: {
-        trigger_type: event.type === "task" ? "task_assign" : event.type === "task_comment" ? "task_comment" : event.type === "wiki_comment" ? "wiki_comment" : event.type === "schedule" ? "schedule_fire" : event.type === "external_trigger" ? "external_trigger" : event.type === "channel_message" ? "channel_message" : event.type === "approval" ? "approval_decided" : "mention",
-        trigger_ref: event.type === "task" ? { task_id: event.targetId } : event.type === "task_comment" ? { comment_id: event.messageId, task_id: event.targetId } : event.type === "wiki_comment" ? { comment_id: event.messageId, target_uri: event.replyTargetUri } : event.type === "schedule" ? { schedule_id: event.targetId, run_id: event.messageId } : event.type === "external_trigger" ? {
-          trigger_id: event.targetId,
-          run_id: event.messageId,
-          connection_id: event.externalConnectionId,
-          ingress_event_id: event.externalIngressEventId
-        } : event.type === "channel_message" ? {
-          conversation_id: event.targetId,
-          channel_message_id: event.messageId,
-          provider: event.channelProvider,
-          external_conversation_id: event.channelExternalConversationId
-        } : event.type === "approval" ? { approval_id: event.messageId } : {
-          message_id: event.messageId,
-          // Thread context for the session→chat backlink:
-          // a thread reply can only be navigated to with
-          // its thread root (the chat surface rejects
-          // bare thread-message targets).
-          ...event.threadRootId ? { thread_root_id: event.threadRootId } : {}
-        },
+        // What the server said about the wake (claim `input`), plus the
+        // source pointer and the anchor the web needs to link a chat
+        // message or a task to this session.
+        trigger_type: input?.trigger_type ?? inputTriggerTypeFor(event.type),
+        trigger_ref: inputTriggerRef(event),
+        source_type: event.ackSourceType,
+        source_id: event.ackSourceId ?? event.messageId,
         sender_id: event.senderId,
-        sender_name: event.senderName,
-        summary: event.body.substring(0, 200),
-        ...event.sentAt ? { sent_at: event.sentAt } : {}
+        ...input?.sender_name ? { sender_name: input.sender_name } : {},
+        summary: (input?.summary ?? eventBody(event)).substring(0, 200),
+        ...input?.sent_at ? { sent_at: input.sent_at } : {}
       }
     });
   }
@@ -58760,13 +58504,14 @@ var ParallAgentGateway = class {
         retainForkContinuationRetries(this.forkContinuationRetries, events, fork.continuationPrefix);
         try {
           const batchText = [];
-          const body = (fork.continuationPrefix ?? "") + buildForkScopePrefix(last) + buildEventBody(last);
+          const bodyPrefix = (fork.continuationPrefix ?? "") + buildForkScopePrefix(last);
+          const body = bodyPrefix + eventBody(last);
           let dispatched;
           if (this.usesLaneLedger(last)) {
             const outcome = await this.dispatchLaneGroup({
               events,
               sessionKey: fork.fork.sessionKey,
-              body,
+              bodyPrefix,
               earlier,
               captureText: batchText,
               // Per-LANE residue check (parity with the main-buffer path):
@@ -58841,9 +58586,9 @@ var ParallAgentGateway = class {
           sourceEvent: {
             type: first.type,
             targetId: fork.targetId,
-            summary: fork.processedEvents.length === 1 ? `${first.type} from ${first.senderName} in ${first.targetName ?? fork.targetId}` : `${fork.processedEvents.length} events in ${first.targetName ?? fork.targetId}`
+            summary: fork.processedEvents.length === 1 ? `${first.type} in ${fork.targetId}` : `${fork.processedEvents.length} events in ${fork.targetId}`
           },
-          eventBodies: fork.processedEvents.map((e) => buildEventBodyForForkResult(e)),
+          eventBodies: fork.processedEvents.map((e) => forkResultBody(e)),
           actions: [],
           agentSummary,
           historyPath
@@ -58914,7 +58659,7 @@ var ParallAgentGateway = class {
             outcome = await this.dispatchLaneGroup({
               events,
               sessionKey: this.opts.runtimeKey,
-              body: forkPrefix + buildEventBody(event),
+              bodyPrefix: forkPrefix,
               earlier,
               hasMoreLocal: () => this.dispatchState.mainBuffer.some((e) => this.dispatchGroupKey(e) === groupKey)
             });
@@ -58956,16 +58701,14 @@ var ParallAgentGateway = class {
             }
           }
           const isTypedGroup = events.every((ev) => ev.type !== "message");
-          const body = isTypedGroup && events.length > 1 && this.opts.dispatchAdapter.earlierEventsInPrompt !== true ? events.map((ev) => buildEventBody(ev)).join("\n\n") : buildEventBody(event);
+          const body = isTypedGroup && events.length > 1 && this.opts.dispatchAdapter.earlierEventsInPrompt !== true ? events.map((ev) => eventBody(ev)).join("\n\n") : eventBody(event);
           let dispatched;
           try {
             dispatched = await this.runDispatch(event, this.opts.runtimeKey, forkPrefix + body, earlier);
           } catch (err) {
             if (!isTypedGroup)
               throw err;
-            this.opts.log?.error(`typed drain dispatch failed for ${event.messageId} (group of ${events.length}, claims freed for re-drive): ${String(err)}`);
-            for (const ev of events)
-              clearTypedDedupeForEvent(this.laneFlowHost(), ev);
+            this.opts.log?.error(`typed drain dispatch failed for ${event.messageId} (group of ${events.length}): ${String(err)}`);
             this.dispatchState.pendingForkResults.unshift(...pendingFork);
             continue;
           }
@@ -58986,7 +58729,6 @@ var ParallAgentGateway = class {
               source_id: sourceId
             }).catch(() => {
             });
-            clearTypedDedupeForEvent(this.laneFlowHost(), bufferedEvent);
           }
         } finally {
           for (const id of drainingIds)
@@ -59029,7 +58771,7 @@ var ParallAgentGateway = class {
               outcome = await this.dispatchLaneGroup({
                 events: [event],
                 sessionKey: this.opts.runtimeKey,
-                body: forkPrefix + buildEventBody(event),
+                bodyPrefix: forkPrefix,
                 earlier: [],
                 hasMoreLocal: () => this.dispatchState.mainBuffer.some((e) => this.dispatchGroupKey(e) === this.dispatchGroupKey(event))
               });
@@ -59061,7 +58803,7 @@ var ParallAgentGateway = class {
         }
         let dispatched = false;
         try {
-          dispatched = await this.runDispatch(event, this.opts.runtimeKey, forkPrefix + buildEventBody(event));
+          dispatched = await this.runDispatch(event, this.opts.runtimeKey, forkPrefix + eventBody(event));
           if (dispatched && typedRefs && this.consumeTurnError(this.opts.runtimeKey)) {
             this.opts.log?.info(`typed dispatch turn for ${event.messageId} surfaced a runtime error \u2014 releasing for retry`);
             dispatched = false;
@@ -59095,7 +58837,7 @@ var ParallAgentGateway = class {
           // the WorkItem stays live, and every re-drive injects it AGAIN (the
           // 7/16 watcher duplicate-delivery loop, #1149). Typed events stay
           // buffered; the drain claims them as their own turn.
-          event.type === "message" && !typedAheadInBuffer && this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, buildEventBody(event))
+          event.type === "message" && event.frame != null && !typedAheadInBuffer && this.dispatchState.mainCurrentTargetId === event.targetId && await this.opts.dispatchAdapter.enqueueDuringDispatch?.(this.opts.runtimeKey, eventBody(event))
         ) {
           this.opts.log?.info(`steer injected for ${event.messageId} (will drain for bookkeeping)`);
         }
@@ -59156,605 +58898,75 @@ var ParallAgentGateway = class {
       }
     }
   }
-  async getOrFetchChatInfo(chatId) {
-    const cached = this.chatInfoMap.get(chatId);
-    if (cached)
-      return cached;
-    try {
-      const chat = await this.opts.client.getChat(this.opts.config.org_id, chatId);
-      const chatInfo = {
-        type: chat.type,
-        name: chat.name ?? null,
-        agentRoutingMode: chat.agent_routing_mode
-      };
-      this.chatInfoMap.set(chatId, chatInfo);
-      return chatInfo;
-    } catch (err) {
-      this.opts.log?.warn(`failed to resolve chat ${chatId}: ${String(err)}`);
-      return null;
-    }
-  }
-  async buildMessageDispatchDecision(chatId, message) {
-    if (message.message_type !== "text") {
-      return { action: "skip" };
-    }
-    const chatInfo = await this.getOrFetchChatInfo(chatId);
-    if (!chatInfo)
-      return { action: "retry" };
-    const content = message.content;
-    const body = content.text?.trim() ?? "";
-    const hasAttachments = message.attachments?.length;
-    if (!body && !hasAttachments)
-      return { action: "skip" };
-    const mentions = content.mentions ?? [];
-    const isMentioned = mentions.some((mention) => mentionTargetsUser(mention.user_id, this.opts.agentUserId, "agent"));
-    let deliveryReason;
-    if (message.thread_root_id) {
-      if (isMentioned) {
-        deliveryReason = "mention";
-      } else {
-        let watching;
-        try {
-          watching = await this.opts.client.isWatchingThread(message.thread_root_id);
-        } catch {
-          return { action: "retry" };
-        }
-        if (!watching)
-          return { action: "skip" };
-        deliveryReason = "watcher";
-      }
-    } else if (chatInfo.type === "group") {
-      if (chatInfo.agentRoutingMode !== "active" && !isMentioned)
-        return { action: "skip" };
-      if (isMentioned)
-        deliveryReason = "mention";
-    }
-    const attachments = (message.attachments ?? []).map((a) => ({
-      id: a.id,
-      fileName: a.file_name,
-      fileSize: a.file_size,
-      mimeType: a.mime_type
-    }));
-    let unreadCount;
-    let unreadSince;
-    let threadReplyCount;
-    let threadUnreadCount;
-    let threadUnreadSince;
-    const isPassiveOrSmart = chatInfo.type === "group" && chatInfo.agentRoutingMode !== "active";
-    const unreadPromise = isPassiveOrSmart ? this.opts.client.getUnreadCounts(this.opts.config.org_id).catch(() => void 0) : Promise.resolve(void 0);
-    const threadPromise = message.thread_root_id ? this.opts.client.getThreadUnread(this.opts.config.org_id, chatId, message.thread_root_id).catch(() => void 0) : Promise.resolve(void 0);
-    const [counts, threadUnread] = await Promise.all([unreadPromise, threadPromise]);
-    if (counts) {
-      const entry = counts[chatId];
-      if (entry && entry.count > 1) {
-        unreadCount = entry.count;
-        unreadSince = entry.since;
-      }
-    }
-    if (threadUnread) {
-      threadReplyCount = threadUnread.total;
-      threadUnreadCount = threadUnread.unread > 0 ? threadUnread.unread : void 0;
-      threadUnreadSince = threadUnread.since ?? void 0;
-    }
-    return {
-      action: "dispatch",
-      event: {
-        type: "message",
-        targetId: chatId,
-        targetName: chatInfo.name ?? void 0,
-        targetType: chatInfo.type,
-        senderId: message.sender_id,
-        senderName: message.sender?.display_name ?? message.sender_id,
-        messageId: message.id,
-        body: body || "[attachment]",
-        threadRootId: message.thread_root_id ?? void 0,
-        deliveryReason,
-        noReply: message.hints?.no_reply ?? false,
-        attachments: attachments.length > 0 ? attachments : void 0,
-        sentAt: message.created_at,
-        ackSourceType: "message",
-        ackSourceId: message.id,
-        unreadCount,
-        unreadSince,
-        threadReplyCount,
-        threadUnreadCount,
-        threadUnreadSince
-      }
-    };
-  }
-  async handleMessage(data) {
+  /**
+   * One WorkItem the server pushed (dispatch.new) or a catch-up page
+   * listed: messages ride their (chat, thread) lane; every other family
+   * rides its own dsp lane, claimed, run on the server frame, resolved by
+   * id. A typed WorkItem whose event copy is already buffered for the
+   * drain is left to the drain (re-claiming it would race the drain's
+   * fence-less settlement).
+   */
+  async consumeWorkItem(item) {
+    await this.contractReady;
     if (this.shuttingDown)
       return;
-    const chatId = data.chat_id;
-    if (data.sender_id === this.opts.agentUserId)
-      return;
-    if (data.message_type !== "text")
-      return;
-    if (!this.tryClaimMessage(data.id))
-      return;
-    const decision = await this.buildMessageDispatchDecision(chatId, data);
-    if (decision.action !== "dispatch") {
-      this.dispatchedMessages.delete(data.id);
+    if (item.event_type === "message") {
+      if (!item.chat_id || !item.source_id)
+        return;
+      await this.consumeMessageWorkItem({
+        id: item.id,
+        source_id: item.source_id,
+        chat_id: item.chat_id,
+        actor_id: item.actor_id,
+        thread_root_id: item.thread_root_id,
+        delivery_reason: item.delivery_reason
+      });
       return;
     }
-    const event = decision.event;
-    try {
-      const dispatched = await this.handleInboundEvent(event);
-      if (dispatched) {
-        if (!this.usesLaneLedger(event)) {
-          this.opts.client.ackDispatch(this.opts.config.org_id, { source_type: "message", source_id: data.id }).catch(() => {
-          });
-        }
-      } else {
-        this.dispatchedMessages.delete(data.id);
-      }
-    } catch (err) {
-      this.opts.log?.error(`event dispatch failed for ${data.id}: ${String(err)}`);
-      this.dispatchedMessages.delete(data.id);
-    }
-  }
-  // Ledger re-drive consumption: dispatch.new message hints re-enter the
-  // shared WorkItem consumption path (same protocol as catch-up).
-  async handleMessageRedrive(item) {
-    if (!item.chat_id || !item.source_id)
+    if (!TYPED_EVENT_KINDS[item.event_type]) {
+      this.opts.log?.info(`dispatch with unhandled event_type=${String(item.event_type)} (id=${item.id}) \u2014 no-op`);
       return;
-    await this.consumeMessageWorkItem({
-      id: item.id,
-      source_id: item.source_id,
-      chat_id: item.chat_id
-    });
-  }
-  // A task assignment's first delivery rides task.assigned, but a typed lane
-  // released without an effect is re-driven as dispatch.new. Reuse the exact
-  // typed claim path used by catch-up so that recovery does not require a
-  // runtime reconnect.
-  async handleTaskAssignmentRedrive(item) {
-    if (!item.task_id)
+    }
+    if (this.isBufferedTypedWorkItem(item.id)) {
+      this.opts.log?.info(`typed dispatch ${item.id} already buffered for the drain \u2014 skipping re-claim`);
       return;
-    await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleTaskDispatch(item.task_id ?? "", item.source_id ?? item.task_id ?? "", {
-      dispatchEventId
-    }), {
-      legacyAck: (dispatchEventId) => this.ackDispatchEvent(dispatchEventId ?? item.id, () => this.clearTypedDispatchDedupe(item)),
-      clearDedupe: () => this.clearTypedDispatchDedupe(item)
-    });
+    }
+    await this.consumeTypedDispatch({ dispatchEventId: item.id }, (lane) => this.runTypedFrame(item, lane), { legacyAck: () => this.ackDispatchEvent(item.id) });
   }
   consumeMessageWorkItem(item) {
     return consumeMessageWorkItem(this.laneFlowHost(), item);
   }
-  async handleTaskAssignment(task, ackSourceId, dispatchEventId) {
-    if (this.shuttingDown)
-      return false;
-    const dedupeKey = `${task.id}:${task.updated_at}`;
-    if (this.dispatchedTasks.has(dedupeKey)) {
-      this.opts.log?.info(`skipping already-dispatched task ${task.identifier ?? task.id}`);
-      return false;
-    }
-    this.dispatchedTasks.add(dedupeKey);
-    this.opts.log?.info(`task assigned: ${task.identifier ?? task.id} "${task.title}"`);
-    const parts = [`Title: ${task.title}`];
-    parts.push(`Status: ${task.status}`, `Priority: ${task.priority}`);
-    if (task.project_id)
-      parts.push(`Project: prll://${task.project_id}`);
-    if (task.parent_id)
-      parts.push(`Parent: prll://${task.parent_id}`);
-    if (task.description)
-      parts.push("", task.description);
-    const event = {
-      type: "task",
-      targetId: task.id,
-      targetName: task.identifier ?? void 0,
-      targetType: "task",
-      senderId: task.creator_id,
-      senderName: "system",
-      messageId: task.id,
-      body: parts.join("\n"),
-      sentAt: task.updated_at ?? task.created_at,
-      ackSourceType: "task_activity",
-      ackSourceId,
-      dispatchEventId
-    };
-    const dispatched = await this.handleInboundEvent(event);
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedTasks.delete(dedupeKey);
-    }
-    return dispatched;
-  }
-  async handleTaskDispatch(taskId, ackSourceId, opts = {}) {
-    let task = null;
-    try {
-      task = await this.opts.client.getTask(this.opts.config.org_id, taskId);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404)
-        return true;
-      throw err;
-    }
-    const isAssignee = task.assignee_id === this.opts.agentUserId;
-    const isCreatorUpdate = opts.allowCreator === true && task.creator_id === this.opts.agentUserId;
-    if (!isAssignee && !isCreatorUpdate) {
-      this.opts.log?.info(`skipping stale task dispatch ${ackSourceId ?? taskId} \u2014 assigned to ${task.assignee_id}, creator ${task.creator_id}`);
-      return true;
-    }
-    return this.handleTaskAssignment(task, ackSourceId, opts.dispatchEventId);
-  }
-  async handleTaskComment(commentId, taskId, actorId, deliveryReason, dispatchEventId) {
-    if (this.shuttingDown)
-      return false;
-    const dedupeKey = `comment:${commentId}`;
-    if (this.dispatchedTasks.has(dedupeKey))
-      return false;
-    this.dispatchedTasks.add(dedupeKey);
-    let comment = null;
-    try {
-      comment = await this.opts.client.getComment(this.opts.config.org_id, commentId);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404) {
-        this.opts.log?.info(`skipping deleted comment ${commentId}, acking stale dispatch`);
-        this.dispatchedTasks.delete(dedupeKey);
-        return true;
-      }
-      this.dispatchedTasks.delete(dedupeKey);
-      return false;
-    }
-    if (!comment) {
-      this.dispatchedTasks.delete(dedupeKey);
-      return true;
-    }
-    if (comment.hints?.no_reply) {
-      this.opts.log?.info(`skipping no_reply task comment ${commentId}, acking stale dispatch`);
-      this.dispatchedTasks.delete(dedupeKey);
-      return true;
-    }
-    let task = null;
-    try {
-      task = await this.opts.client.getTask(this.opts.config.org_id, taskId);
-    } catch {
-    }
-    const taskLabel = task ? `${task.identifier ?? task.id} "${task.title}"` : taskId;
-    this.opts.log?.info(`task comment on ${taskLabel} by ${actorId ?? "unknown"}`);
-    const parts = [];
-    if (task) {
-      parts.push(`Task: ${task.title} (prll://${task.id})`);
-      parts.push(`Status: ${task.status}`, `Priority: ${task.priority}`);
-    } else {
-      parts.push(`Task: prll://${taskId}`);
-    }
-    parts.push(`Comment by: ${comment.author?.display_name ?? actorId ?? "unknown"} (prll://${comment.author_id})`);
-    parts.push("", comment.body);
-    const event = {
-      type: "task_comment",
-      targetId: taskId,
-      targetName: task?.identifier ?? void 0,
-      targetType: "task",
-      senderId: comment.author_id,
-      senderName: comment.author?.display_name ?? actorId ?? "unknown",
-      messageId: commentId,
-      body: parts.join("\n"),
-      deliveryReason: deliveryReason ?? void 0,
-      ackSourceType: "comment",
-      ackSourceId: commentId,
-      dispatchEventId
-    };
-    let dispatched;
-    try {
-      dispatched = await this.handleInboundEvent(event);
-    } catch (err) {
-      this.dispatchedTasks.delete(dedupeKey);
-      throw err;
-    }
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedTasks.delete(dedupeKey);
-    }
-    return dispatched;
-  }
-  async handleWikiComment(commentId, actorId, deliveryReason, dispatchEventId) {
-    if (this.shuttingDown)
-      return false;
-    const dedupeKey = `comment:${commentId}`;
-    if (this.dispatchedTasks.has(dedupeKey))
-      return false;
-    this.dispatchedTasks.add(dedupeKey);
-    let comment = null;
-    try {
-      comment = await this.opts.client.getComment(this.opts.config.org_id, commentId);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404 || status === 403) {
-        this.opts.log?.info(`skipping inaccessible wiki comment ${commentId} (status ${status}), acking stale dispatch`);
-        this.dispatchedTasks.delete(dedupeKey);
-        return true;
-      }
-      this.dispatchedTasks.delete(dedupeKey);
-      return false;
-    }
-    if (!comment) {
-      this.dispatchedTasks.delete(dedupeKey);
-      return true;
-    }
-    if (comment.hints?.no_reply) {
-      this.opts.log?.info(`skipping no_reply wiki comment ${commentId}, acking stale dispatch`);
-      this.dispatchedTasks.delete(dedupeKey);
-      return true;
-    }
-    const target = parseWikiCommentTarget(comment.target_uri);
-    this.opts.log?.info(`wiki comment on ${target.label} by ${actorId ?? "unknown"}`);
-    const event = {
-      type: "wiki_comment",
-      // Full target_uri (scheme-stripped) is the routing key so different
-      // pages / inline anchors / changesets in the same wiki don't collide on
-      // one gateway lane. replyTargetUri keeps the canonical prll:// form.
-      targetId: target.routingKey,
-      targetName: target.label,
-      targetType: target.targetType,
-      senderId: comment.author_id,
-      senderName: comment.author?.display_name ?? actorId ?? "unknown",
-      messageId: commentId,
-      body: comment.body,
-      deliveryReason: deliveryReason ?? void 0,
-      replyTargetUri: comment.target_uri,
-      ackSourceType: "comment",
-      ackSourceId: commentId,
-      dispatchEventId
-    };
-    let dispatched;
-    try {
-      dispatched = await this.handleInboundEvent(event);
-    } catch (err) {
-      this.dispatchedTasks.delete(dedupeKey);
-      throw err;
-    }
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedTasks.delete(dedupeKey);
-    }
-    return dispatched;
-  }
   /**
-   * Fetch the schedule_run snapshot, then feed it as an inbound event. 404 is
-   * tolerated and treated as "dispatched" so the caller can ack the stale
-   * delivery — see `docs/primitives/schedule.md` § "Snapshot 不变性: 内容 vs
-   * 可见性". A later PATCH on target_id / attached_to_uri legitimately revokes
-   * access to already-delivered run snapshots, and the runtime must not crash
-   * or retry forever in that case.
+   * Run one claimed typed WorkItem on the frame the claim returned. The
+   * event is addressing only: the routing target the server named
+   * (`input.subject` — the task, the wiki target, the schedule, the
+   * conversation, the chat an approval belongs to), the ids the ledger
+   * keys on, and the input-step metadata. No frame means nothing to run.
    */
-  async fetchAndHandleScheduleFire(runId, actorId, dispatchEventId) {
-    let run = null;
-    try {
-      run = await this.opts.client.getScheduleRun(this.opts.config.org_id, runId);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404) {
-        this.opts.log?.warn(`schedule run ${runId} not accessible (404), acking stale dispatch`);
-        return true;
-      }
-      this.opts.log?.warn(`schedule run fetch failed for ${runId}, leaving pending: ${String(err)}`);
-      return false;
-    }
-    if (!run)
-      return true;
-    return this.handleScheduleFire(run, actorId, dispatchEventId);
-  }
-  async handleScheduleFire(run, actorId, dispatchEventId) {
+  async runTypedFrame(item, lane) {
     if (this.shuttingDown)
       return false;
-    const dedupeKey = `schedule_run:${run.id}`;
-    if (this.dispatchedTasks.has(dedupeKey))
-      return false;
-    this.dispatchedTasks.add(dedupeKey);
-    this.opts.log?.info(`schedule fired: ${run.id} (schedule ${run.schedule_id})`);
-    const event = {
-      type: "schedule",
-      // Route by schedule_id (not attached chat_id) so concurrent fires of
-      // different schedules can fork independently — matches the PR1 primitive
-      // design where "schedule triggers; target decides response" and fire
-      // semantics are independent of any attached conversation.
-      targetId: run.schedule_id,
-      targetType: "schedule",
-      senderId: actorId ?? "system",
-      senderName: "schedule",
-      messageId: run.id,
-      body: run.fired_description ?? "",
-      scheduledFireAt: run.scheduled_fire_at,
-      attachedUri: run.fired_attached_uri ?? void 0,
-      ackSourceType: "schedule_run",
-      ackSourceId: run.id,
-      dispatchEventId
-    };
-    let dispatched;
-    try {
-      dispatched = await this.handleInboundEvent(event);
-    } catch (err) {
-      this.dispatchedTasks.delete(dedupeKey);
-      throw err;
-    }
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedTasks.delete(dedupeKey);
-    }
-    return dispatched;
-  }
-  async fetchAndHandleExternalTriggerRun(runId, dispatchEventId) {
-    let run = null;
-    try {
-      run = await this.opts.client.getExternalTriggerRun(this.opts.config.org_id, runId);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404) {
-        this.opts.log?.warn(`external trigger run ${runId} not accessible (404), acking stale dispatch`);
-        return true;
-      }
-      this.opts.log?.warn(`external trigger run fetch failed for ${runId}, leaving pending: ${String(err)}`);
-      return false;
-    }
-    if (!run)
-      return true;
-    return this.handleExternalTriggerRun(run, dispatchEventId);
-  }
-  // fetchAndHandleChannelMessage resolves a channel_message dispatch to its
-  // durable ChannelMessage + conversation and hands it to the inbound
-  // pipeline. targetId = the ChannelConversation id, so per-conversation
-  // multi-turn continuity rides the same per-target session mechanics as
-  // chats. Design: docs/engineering-design/external-im-channel-design.md.
-  async fetchAndHandleChannelMessage(messageId, dispatchEventId) {
-    if (this.shuttingDown)
-      return false;
-    const claimKey = `channel_message:${messageId}`;
-    if (!this.tryClaimMessage(claimKey))
-      return false;
-    let msg = null;
-    let conv = null;
-    try {
-      msg = await this.opts.client.getChannelMessage(this.opts.config.org_id, messageId);
-      conv = await this.opts.client.getChannelConversation(this.opts.config.org_id, msg.conversation_id);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404) {
-        this.opts.log?.warn(`channel message ${messageId} not accessible (404), acking stale dispatch`);
-        return true;
-      }
-      this.dispatchedMessages.delete(claimKey);
-      this.opts.log?.warn(`channel message fetch failed for ${messageId}, leaving pending: ${String(err)}`);
-      return false;
-    }
-    if (!msg || !conv) {
-      return true;
-    }
-    this.opts.log?.info(`channel message: ${msg.id} (conversation ${conv.id})`);
-    let provider = this.channelConnectionProviders.get(conv.connection_id);
-    if (!provider) {
-      try {
-        const connection = await this.opts.client.getChannelConnection(this.opts.config.org_id, conv.connection_id);
-        provider = connection.provider;
-        this.channelConnectionProviders.set(conv.connection_id, provider);
-      } catch {
-        provider = void 0;
-      }
-    }
-    const keys = this.opts.getCapabilityKeys?.() ?? [];
-    const cliCapable = provider ? keys.includes(channelCapabilityKeyFor(provider)) : keys.some((k) => k.endsWith("-cli") || k === CAPABILITY_SLACK_SEND || k === CAPABILITY_WECHAT_SEND);
-    const event = {
-      type: "channel_message",
-      targetId: conv.id,
-      targetName: conv.external_conversation_name || conv.external_user_name || conv.external_conversation_id,
-      targetType: "channel_conversation",
-      senderId: msg.external_user_id || "external",
-      senderName: msg.external_user_name || msg.external_user_id || "external user",
-      messageId: msg.id,
-      body: msg.text,
-      sentAt: msg.received_at,
-      channelProvider: provider,
-      channelConversationType: conv.conversation_type || void 0,
-      channelExternalConversationId: conv.external_conversation_id,
-      channelExternalConversationName: conv.external_conversation_name || void 0,
-      channelExternalMessageId: msg.external_message_id,
-      channelCliCapable: cliCapable,
-      ackSourceType: "channel_message",
-      ackSourceId: msg.id,
-      dispatchEventId
-    };
-    let dispatched;
-    try {
-      dispatched = await this.handleInboundEvent(event);
-    } catch (err) {
-      this.dispatchedMessages.delete(claimKey);
-      throw err;
-    }
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedMessages.delete(claimKey);
-    }
-    return dispatched;
-  }
-  async handleExternalTriggerRun(run, dispatchEventId) {
-    if (this.shuttingDown)
-      return false;
-    const dedupeKey = `external_trigger_run:${run.id}`;
-    if (this.dispatchedTasks.has(dedupeKey))
-      return false;
-    this.dispatchedTasks.add(dedupeKey);
-    this.opts.log?.info(`external trigger fired: ${run.id} (trigger ${run.trigger_id})`);
-    const attachedUri = typeof run.trigger_snapshot?.attached_to_uri === "string" ? run.trigger_snapshot.attached_to_uri : void 0;
-    const event = {
-      type: "external_trigger",
-      targetId: run.trigger_id,
-      targetName: run.trigger_name || void 0,
-      targetType: "external_trigger",
-      senderId: "system",
-      senderName: "external",
-      messageId: run.id,
-      body: run.agent_input_body ?? "",
-      externalConnectionId: run.connection_id,
-      externalConnectionSourceType: run.connection_source_type || void 0,
-      externalConnectionDisplayName: run.connection_display_name || void 0,
-      externalIngressEventId: run.ingress_event_id,
-      externalIngressEventType: run.ingress_event_type || void 0,
-      attachedUri,
-      ackSourceType: "external_trigger_run",
-      ackSourceId: run.id,
-      dispatchEventId
-    };
-    let dispatched;
-    try {
-      dispatched = await this.handleInboundEvent(event);
-    } catch (err) {
-      this.dispatchedTasks.delete(dedupeKey);
-      throw err;
-    }
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedTasks.delete(dedupeKey);
-    }
-    return dispatched;
-  }
-  async fetchAndHandleApprovalDecided(approvalId, actorId, chatId, dispatchEventId) {
-    let approval = null;
-    try {
-      approval = await this.opts.client.getApproval(approvalId);
-    } catch (err) {
-      const status = err?.status;
-      if (status === 404 || status === 403) {
-        this.opts.log?.warn(`approval ${approvalId} not accessible (${status}), acking stale dispatch`);
-        return true;
-      }
-      this.opts.log?.warn(`approval fetch failed for ${approvalId}, leaving pending: ${String(err)}`);
+    const wake = this.laneLedger?.takeFrame(lane);
+    if (!wake?.frame) {
+      this.opts.log?.warn(`typed dispatch ${item.id} (${String(item.event_type)}) claimed without a frame \u2014 leaving it pending`);
       return false;
     }
-    if (!approval)
-      return true;
-    if (this.shuttingDown)
-      return false;
-    const dedupeKey = `approval:${approval.id}`;
-    if (this.dispatchedTasks.has(dedupeKey))
-      return false;
-    this.dispatchedTasks.add(dedupeKey);
-    this.opts.log?.info(`approval decided: ${approval.id} (${approval.status})`);
-    const statusLabel = approval.status === "approved" ? "Approved" : "Rejected";
-    const execInfo = approval.execution_status ? ` | execution: ${approval.execution_status}` : "";
-    const reasonLine = formatApprovalDecisionReason(approval.status, approval.decision_reason);
-    const reasonInfo = reasonLine ? `
-${reasonLine}` : "";
-    const body = `${statusLabel}: ${approval.title}${execInfo}${reasonInfo}`;
+    const kind = TYPED_EVENT_KINDS[item.event_type];
+    const targetId = wake.input?.subject || item.task_id || item.chat_id || item.source_id || item.id;
     const event = {
-      type: "approval",
-      targetId: chatId ?? approval.chat_id,
-      senderId: actorId ?? approval.decided_by ?? "system",
-      senderName: "approver",
-      messageId: approval.id,
-      body,
-      // The WorkItem's real source pair. Without it the legacy fallback
-      // guessed ('message', approval_id) — a pair no row matches.
-      ackSourceType: "approval",
-      ackSourceId: approval.id,
-      dispatchEventId
-    };
-    let dispatched;
-    try {
-      dispatched = await this.handleInboundEvent(event);
-    } catch (err) {
-      this.dispatchedTasks.delete(dedupeKey);
-      throw err;
-    }
-    if (!dispatched && !this.isTypedEventBuffered(event)) {
-      this.dispatchedTasks.delete(dedupeKey);
-    }
-    return dispatched;
+      type: kind.type,
+      targetId,
+      targetType: wake.input?.step_target?.type,
+      senderId: wake.input?.sender_id ?? item.actor_id ?? "system",
+      messageId: item.source_id,
+      deliveryReason: item.delivery_reason ?? void 0,
+      ackSourceType: kind.ackSourceType,
+      ackSourceId: item.source_id,
+      dispatchEventId: item.id
+    };
+    applyWake(event, wake);
+    this.opts.log?.info(`${String(item.event_type)} ${item.source_id} \u2192 ${targetId}`);
+    return this.handleInboundEvent(event);
   }
   async catchUpFromDispatch() {
     const OVERFLOW_THRESHOLD = 500;
@@ -59808,54 +59020,9 @@ ${reasonLine}` : "";
           }
           continue;
         }
-        if (item.event_type !== "message" && this.isBufferedTypedWorkItem(item.id)) {
-          this.opts.log?.info(`typed dispatch ${item.id} already buffered for the drain \u2014 skipping catch-up claim`);
-          continue;
-        }
         processed++;
         try {
-          const typedHooks = {
-            legacyAck: () => this.ackDispatchEvent(item.id, () => this.clearTypedDispatchDedupe(item)),
-            clearDedupe: () => this.clearTypedDispatchDedupe(item)
-          };
-          if (item.event_type === "task_assign" && item.task_id) {
-            try {
-              await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleTaskDispatch(item.task_id ?? "", item.source_id ?? item.task_id ?? "", {
-                dispatchEventId
-              }), typedHooks);
-            } catch (err) {
-              this.opts.log?.warn(`catch-up task fetch failed for ${item.task_id}, leaving pending: ${String(err)}`);
-              continue;
-            }
-          } else if (item.event_type === "task_update" && item.task_id) {
-            try {
-              await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleTaskDispatch(item.task_id ?? "", item.source_id ?? item.task_id ?? "", {
-                allowCreator: true,
-                dispatchEventId
-              }), typedHooks);
-            } catch (err) {
-              this.opts.log?.warn(`catch-up task fetch failed for ${item.task_id}, leaving pending: ${String(err)}`);
-              continue;
-            }
-          } else if (item.event_type === "task_comment" && item.source_id && item.task_id) {
-            await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleTaskComment(item.source_id, item.task_id ?? "", item.actor_id, item.delivery_reason, dispatchEventId), typedHooks);
-          } else if (item.event_type === "wiki_comment" && item.source_id) {
-            await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.handleWikiComment(item.source_id, item.actor_id, item.delivery_reason, dispatchEventId), typedHooks);
-          } else if (item.event_type === "schedule.fire" && item.source_id) {
-            await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.fetchAndHandleScheduleFire(item.source_id, item.actor_id, dispatchEventId), typedHooks);
-          } else if (item.event_type === "external_trigger" && item.source_id) {
-            await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.fetchAndHandleExternalTriggerRun(item.source_id, dispatchEventId), typedHooks);
-          } else if (item.event_type === "channel_message" && item.source_id) {
-            await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.fetchAndHandleChannelMessage(item.source_id, dispatchEventId), typedHooks);
-          } else if (item.event_type === "approval_decided" && item.source_id) {
-            await this.consumeTypedDispatch({ dispatchEventId: item.id }, (dispatchEventId) => this.fetchAndHandleApprovalDecided(item.source_id, item.actor_id, item.chat_id ?? null, dispatchEventId), typedHooks);
-          } else if (item.event_type === "message" && item.source_id && item.chat_id) {
-            await this.consumeMessageWorkItem({
-              id: item.id,
-              source_id: item.source_id,
-              chat_id: item.chat_id
-            });
-          }
+          await this.consumeWorkItem(item);
         } catch (err) {
           this.opts.log?.warn(`catch-up dispatch ${item.id} (${item.event_type}) failed: ${String(err)}`);
         }
@@ -59928,9 +59095,18 @@ ${fullSummary}` : fullSummary;
       this.ledgerDisabled = false;
     }
     const intervalSec = data.heartbeat_interval > 0 ? data.heartbeat_interval : 30;
+    let openFence = () => {
+    };
+    this.contractReady = new Promise((resolve4) => {
+      openFence = resolve4;
+    });
     try {
-      const count = await fetchAllChats(client, config.org_id, this.chatInfoMap);
-      log2?.info(`WebSocket connected, ${count} chats cached`);
+      log2?.info("WebSocket connected");
+      try {
+        await this.declareRuntimeContract();
+      } finally {
+        openFence();
+      }
       await this.opts.onSessionReady?.({
         activeSessionId: this.activeSessionId,
         ws: this.opts.ws,
@@ -59964,6 +59140,44 @@ ${fullSummary}` : fullSummary;
       log2?.error(`failed to fetch chats: ${String(err)}`);
     }
   }
+  /**
+   * Declare the runtime contract for this connection: the server decides
+   * who runs and renders the wake frame; this runtime only runs. Bound to
+   * the WS session id, so it repeats on every hello. Retried with backoff
+   * until it lands — WorkItems wait behind the fence meanwhile, nothing is
+   * claimed without a frame. A server without the endpoint renders no
+   * frames: the runtime runs nothing and WorkItems stay pending. A
+   * stale-session 409 means a newer connection already declared.
+   */
+  async declareRuntimeContract() {
+    const session = this.sessionId;
+    if (!session)
+      return;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await this.opts.client.declareReplyPolicyCapability(this.opts.config.org_id, session);
+        this.opts.log?.info("runtime contract declared (server-rendered frames)");
+        return;
+      } catch (err) {
+        if (err instanceof ApiError && err.status === 404) {
+          this.opts.log?.warn("server predates the runtime contract \u2014 it renders no wake frames; WorkItems stay pending");
+          return;
+        }
+        if (err instanceof ApiError && err.status === 409) {
+          this.opts.log?.info("runtime contract already declared by a newer connection");
+          return;
+        }
+        const delayMs = Math.min(3e4, 2e3 * 2 ** Math.min(attempt, 4));
+        this.opts.log?.warn(`runtime contract declaration failed (retry in ${delayMs / 1e3}s): ${String(err)}`);
+        await new Promise((resolve4) => {
+          const timer = setTimeout(resolve4, delayMs);
+          timer.unref?.();
+        });
+        if (this.shuttingDown || this.sessionId !== session)
+          return;
+      }
+    }
+  }
   // Resolves when in-flight dispatches hit 0 or the deadline elapses.
   // Deadline arming the resolver rather than rejecting keeps shutdown() linear
   // — callers don't need to try/catch.
@@ -60111,36 +59325,46 @@ function saveCache(stateDir, response) {
   fs4.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
   fs4.renameSync(tmpPath, filePath);
 }
-function runtimeModelName(canonicalModel, runtimeType, config) {
+function runtimeModelConfig(canonicalModel, runtimeType, config) {
   const runtime = runtimeType?.trim();
-  if (!runtime || runtime === "openclaw" || runtime === "hermes")
-    return canonicalModel;
   const models = config.models ?? {};
   const providers = models.providers ?? {};
   const parall = providers.parall ?? {};
   const catalog = Array.isArray(parall.models) ? parall.models : [];
   const match = catalog.find((model) => model.id === canonicalModel);
-  if (!match)
-    return null;
+  if (!match) {
+    return !runtime || runtime === "openclaw" || runtime === "hermes" ? { model: canonicalModel, contextWindow: null } : null;
+  }
+  const contextWindow = typeof match.contextWindow === "number" && Number.isSafeInteger(match.contextWindow) && match.contextWindow > 0 ? match.contextWindow : null;
+  if (!runtime || runtime === "openclaw" || runtime === "hermes") {
+    return { model: canonicalModel, contextWindow };
+  }
   const runtimeNames = match.runtime_names ?? {};
   const runtimeName = runtimeNames[runtime];
-  if (typeof runtimeName === "string" && runtimeName)
-    return runtimeName;
-  return canonicalModel;
+  if (typeof runtimeName === "string" && runtimeName) {
+    return {
+      model: runtimeName,
+      contextWindow: runtimeName === canonicalModel ? contextWindow : null
+    };
+  }
+  return { model: canonicalModel, contextWindow };
 }
 function extractDefaults(config, runtimeType) {
   const agents = config.agents ?? {};
   const defaults = agents.defaults ?? {};
   let model = null;
+  let contextWindow = null;
   if (typeof defaults.model === "string" && defaults.model) {
     const canonicalModel = defaults.model.replace(/^parall-anthropic\//, "").replace(/^parall\//, "");
-    model = runtimeModelName(canonicalModel, runtimeType, config);
+    const resolved = runtimeModelConfig(canonicalModel, runtimeType, config);
+    model = resolved?.model ?? null;
+    contextWindow = resolved?.contextWindow ?? null;
   }
   let thinkingEffort = null;
   if (typeof defaults.thinking_effort === "string" && defaults.thinking_effort) {
     thinkingEffort = defaults.thinking_effort;
   }
-  return { model, thinkingEffort };
+  return { model, thinkingEffort, contextWindow };
 }
 function createPlatformConfigManager(opts) {
   const { client, stateDir, runtimeType, log: log2 } = opts;
@@ -60148,6 +59372,7 @@ function createPlatformConfigManager(opts) {
   let currentDefaults = {
     model: null,
     thinkingEffort: null,
+    contextWindow: null,
     modelIsPin: void 0
   };
   let currentRawConfig = null;
@@ -60425,7 +59650,9 @@ parall approvals wait prll://apr_xxx --timeout 300
 # List all your pending approvals
 parall approvals list
 
-# List available approvable actions
+# List available approvable actions \u2014 the output includes each documented
+# action's payload contract (exact field names, and where a CAS base like
+# expected_version is read from). Check it before hand-writing a --payload.
 parall approvals actions
 
 # Cancel a pending request you made
@@ -60611,8 +59838,19 @@ parall tasks update prll://tsk_xxx --planned-start none
 # Move a task to the end of its status column
 parall tasks update prll://tsk_xxx --placement end
 
-# Add a comment
-parall tasks comments add prll://tsk_xxx --body "Progress update..."
+# Add a comment \u2014 same shell rules as messages: the body runs through a
+# shell, so pass real content via --body-file (a written file, or a quoted
+# heredoc into stdin with '-'). --body "..." only for short literals with
+# no $, backtick, or quote (single or double). A bare --body - is refused,
+# not stdin.
+parall tasks comments add prll://tsk_xxx --body-file - <<'PARALL_EOF'
+Progress update: fixed the $1,000 rounding bug, it's in review.
+PARALL_EOF
+parall tasks comments add prll://tsk_xxx --body-file /tmp/comment.md
+parall tasks comments add prll://tsk_xxx --body "On it"
+
+# Long or multi-line description \u2192 same file / stdin channel
+parall tasks create --title "Write the runbook" --project-id prll://prj_xxx --description-file /tmp/description.md
 \`\`\`
 
 Ordering: to append a task to the end of a status column, always use
@@ -60689,7 +59927,7 @@ When you receive \`[Event: task.comment.created]\`, someone commented on a task
 
 1. Resolve the project and read its current description as described above
 2. Review the comment content and task context
-3. Reply via comment: \`tasks comments add prll://tsk_xxx --body "Response..."\`
+3. Reply via comment: \`tasks comments add prll://tsk_xxx --body-file -\` with a quoted heredoc (\`--body "..."\` only for short literals with no \`$\`, backtick, or quote \u2014 single or double)
 4. If the comment requests status changes, update accordingly
 
 CLI success output is JSON; errors print a JSON line plus, on a \`PERMISSION_DENIED\`, an optional plain-text \`Request approval:\` line \u2014 read both.