openvisio-agent 0.25.10 → 0.25.11

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.25.11] — 2026-09-21
+
+- Explain and enforce task ownership identity: `assignee_id` is for human members, while `agent_id` is for registered agents, and task mutations cannot send both.
+- Keep agent messages, task comments, titles, and descriptions within readable limits at the shared MCP bridge; watcher-owned oversized replies are shortened while full output remains in Agent Studio.
+- Stop automated peer exchanges after one agent reply until a human speaks, suppress sender-less echoes of watcher comments, and ignore explicitly self-authored task status events before they start another cycle.
+
 ## [0.25.10] — 2026-09-21
 
 - Send `thinking`, `working`, and `typing` activity through the authenticated agent WebSocket, with the REST endpoint retained only while the socket is reconnecting.

package/README.md

@@ -87,7 +87,7 @@ The backend MCP may be stateful or stateless. A successful initialize response w
 
 Codex BYO agents follow the repository's normative runtime specification in `docs/CODEX_BYO_AGENT_SPEC.md`: one WebSocket identity, independent reply/work queues, authoritative `get_ticket` verification for assignments, silent transient activity, persistent replay suppression, and agent-controlled turn completion. Maintainers must run `npm run certify` before publishing.
 
-Both `agent:mention` and organization `channel:message` events pass through the same source-recipient, ownership, and deduplication checks before any model starts. The watcher hydrates compact roster entries through `get_agent`, subscribes only to the organization verified from that authenticated profile, and restores the subscription after reconnect. Organization `task:created` and `task:updated` events enter the same authoritative assignment verifier as targeted `task:assigned` events, so a task starts only after `get_ticket` confirms it is open and owned by this agent. Self-authored source messages are ignored; embedded old agent replies cannot hide a human follow-up. An explicit tag establishes durable ownership of that thread, so later human follow-ups remain addressed to the agent without another @mention. Another BYO agent can continue that owned thread with a concrete question or request without repeating the mention; routine agent status chatter remains silent to prevent reply loops. Ticket-inventory intent is sentence-scoped, so a peer saying it has no assigned tickets cannot hijack a separate onboarding or coordination question. Messages redirected to another agent stay silent, while a direct stand-down cancels queued/running work and releases ownership for that thread. Concrete roots verified as belonging to someone else have a bounded one-minute cache; missing authors and failed reads remain immediately retryable. The watcher publishes working, thinking, and typing presence from actual runtime activity using the authenticated REST endpoint. It stops refreshing when work finishes or is cancelled; the app clears the indicator through its expiry timer. Accepted coding tasks publish a short native plan first; the watcher sends one acknowledgement with up to three steps to the source thread or default agent channel. Every runtime returns a distinct final answer for guarded watcher delivery. Plans and reconnects cannot duplicate or suppress that final answer.
+Both `agent:mention` and organization `channel:message` events pass through the same source-recipient, ownership, and deduplication checks before any model starts. The watcher hydrates compact roster entries through `get_agent`, subscribes only to the organization verified from that authenticated profile, and restores the subscription after reconnect. Organization `task:created` and `task:updated` events enter the same authoritative assignment verifier as targeted `task:assigned` events, so a task starts only after `get_ticket` confirms it is open and owned by this agent. Explicit self-authored task updates and source messages are ignored; embedded old agent replies cannot hide a human follow-up. An explicit tag establishes durable ownership of that thread, so later untagged human follow-ups remain addressed to the agent. Another BYO agent can make one concrete request after the latest human turn; after this agent answers, further peer turns stay silent until a human speaks. Routine agent chatter, reciprocal questions, and sender-less echoes of watcher-delivered task comments remain silent. Ticket-inventory intent is sentence-scoped, so a peer saying it has no assigned tickets cannot hijack a separate onboarding or coordination question. Messages redirected to another agent stay silent, while a direct stand-down cancels queued/running work and releases ownership for that thread. Agent messages and comments are kept within 1,200 characters, and task mutations expose the distinction between human `assignee_id` and agent `agent_id`. Concrete roots verified as belonging to someone else have a bounded one-minute cache; missing authors and failed reads remain immediately retryable. The watcher publishes working, thinking, and typing presence from actual runtime activity using the authenticated REST endpoint. It stops refreshing when work finishes or is cancelled; the app clears the indicator through its expiry timer. Accepted coding tasks publish a short native plan first; the watcher sends one acknowledgement with up to three steps to the source thread or default agent channel. Every runtime returns a distinct final answer for guarded watcher delivery. Plans and reconnects cannot duplicate or suppress that final answer.
 
 Ticket references follow the board UI: BYO agents use the project-scoped slug, such as `OVS-57`, in messages, comments, PR descriptions, blockers, and results. Numeric `project_id` and `ticket_id` values remain internal MCP arguments and are never used as human-facing ticket names. If an older backend omits the slug, the agent uses the ticket title rather than inventing one.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.25.10",
+  "version": "0.25.11",
   "description": "Connect Claude Code, Codex, OpenCode, Gemini CLI, or Qwen Code to an OpenVisio team \u2014 MCP tools + optional autonomy \u2014 in one command.",
   "type": "module",
   "bin": {

package/scripts/certify.mjs

@@ -30,6 +30,7 @@ const mcpHttp = readFileSync(join(root, 'src', 'mcp-http.mjs'), 'utf8')
 const opencodeConfig = readFileSync(join(root, 'src', 'opencode-config.mjs'), 'utf8')
 const codexConfig = readFileSync(join(root, 'src', 'codex-config.mjs'), 'utf8')
 const codexProxy = readFileSync(join(root, 'src', 'codex-mcp-proxy.mjs'), 'utf8')
+const toolPolicy = readFileSync(join(root, 'src', 'tool-policy.mjs'), 'utf8')
 const prPush = readFileSync(join(root, 'src', 'pr-push.mjs'), 'utf8')
 const cli = readFileSync(join(root, 'bin', 'cli.mjs'), 'utf8')
 const websocket = readFileSync(join(root, 'src', 'ws.mjs'), 'utf8')
@@ -59,6 +60,9 @@ const assertions = [
   ['connection recovery scans assignments without an activity-feed pass', watcher.includes('const reconcileBacklog') && watcher.includes("await handleTaskSignal('task:assigned'") && !watcher.includes('reconcileActivity')],
   ['task:assigned is handled', watcher.includes("k === 'task:assigned'")],
   ['task creation and update fanout use the assignment verifier', watcher.includes("k === 'task:created'") && watcher.includes("k === 'task:updated'") && watcher.includes('return handleTaskSignal(k, raw)')],
+  ['task ownership distinguishes human assignees from registered agents', toolPolicy.includes('assignee_id is only for a human user/member id') && toolPolicy.includes('agent_id is only for a registered coding agent id') && codexProxy.includes('validateAgentToolArguments')],
+  ['agent-authored task updates stop before ticket verification', watcher.includes("kind === 'task:updated'") && watcher.includes('taskEventSenderIsSelf(raw') && events.includes('export function taskEventSenderIsSelf')],
+  ['agent communication has shared readable limits', toolPolicy.includes('post_message:') && toolPolicy.includes('max: 1200') && toolPolicy.includes('compactAgentMessage') && watcher.includes('compactAgentMessage(content, { maxChars: 1200 })')],
   ['compact agent records are hydrated before organization subscription', watcher.includes("callMcpTool('get_agent', { agent_id: selfAgentId })") && watcher.includes('selfAgentId != null && selfOrganizationId == null')],
   ['task signals are verified with get_ticket', watcher.includes("callMcpTool('get_ticket'")],
   ['review and testing handoffs do not restart work', watcher.includes('taskIsAwaitingReview(task, reviewIds)') && watcher.includes('taskIsAwaitingReview(ticket, typeSets.review)')],
@@ -67,13 +71,14 @@ const assertions = [
   ['agent results are delivered independently of ticket completion', watcher.includes('agentFinal: true') && watcher.includes('pendingAgentResults')],
   ['completion delivery survives reconnect and deduplicates', watcher.includes('pendingCompletionReports: [...pendingCompletionReports]') && watcher.includes('reportedCompletions: [...reportedCompletions]') && watcher.includes('reportedCompletions.has(report.key)')],
   ['optional ticket comments cannot block verified completion', watcher.includes('callOptionalTicketComment({ projectId, ticketId, content: report.content })') && watcher.includes('no ticket comment tool is exposed; completing ticket') && watcher.includes('reportedTaskComments: [...reportedTaskComments]') && watcher.includes('reportedTaskComments.has(report.key)')],
-  ['ticket comments prefer the advertised modern schema with legacy compatibility', watcher.includes("names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''") && watcher.includes("name === 'create_task_comment'") && watcher.includes("{ parent_id: Number(parentId) }") && watcher.includes("{ text: content }")],
+  ['ticket comments prefer the advertised modern schema with legacy compatibility', watcher.includes("names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''") && watcher.includes("name === 'create_task_comment'") && watcher.includes("{ parent_id: Number(parentId) }") && watcher.includes("{ content: message") && watcher.includes("{ text: message }")],
   ['uncertain comment writes never trigger duplicate alternate ticket writes', watcher.includes('never try another comment endpoint after an error') && watcher.includes('no alternate ticket write will be attempted') && !watcher.includes("reason: 'not-available'")],
   ['ticket comments cannot masquerade as channel completion', events.includes("didChannelMessage: completed && mcpTool === 'post_message'") && watcher.includes('result.didChannelMessage')],
   ['single-watcher acquisition is atomic and fails closed', watcher.includes("openSync(lockPath, 'wx')") && watcher.includes('Could not acquire the single-watcher lock')],
   ['websocket mention delivery uses a persistent replay guard', watcher.includes('markMentionHandled(msg, cid)') && watcher.includes('recentMentionSignatures')],
   ['conversation wake events preserve owned-thread follow-ups and filter other recipients before model start', watcher.includes("memory.has(controlKey, 'active')") && watcher.includes('classifyConversationTarget(msg, [...selfAliases], { threadOwned })') && events.includes("'owned-thread-follow-up'") && events.includes("reason: 'explicit-other-recipient'") && events.includes("reason: 'other-agent-chatter'")],
   ['owned threads admit concrete peer requests without opening agent chatter loops', events.includes("reason: peerFollowUp ? 'owned-peer-follow-up'") && watcher.includes('This request was authored by another team agent') && watcher.includes('do not append a reciprocal question')],
+  ['peer-agent exchanges stop after one reply until a human turn', watcher.includes("state: 'replied'") && watcher.includes("state: 'human'") && watcher.includes('peer-loop-budget') && watcher.includes('ignored-peer-loop')],
   ['pending-ticket intent is scoped to one clause', events.includes("text.split(/(?<=[.!?])") && events.includes('return tasks && pending && question')],
   ['prematurely acknowledged owned-thread replies recover exactly once', watcher.includes("!threadOwned || memory.has(sourceKey, 'received')") && watcher.includes('agent:mention replay recovered for active owned thread')],
   ['task comments use assigned-ticket verification and watcher-owned threaded delivery', watcher.includes("k === 'task:comment'") && watcher.includes('taskCommentFromEvent(raw)') && watcher.includes('postTaskCommentOnce') && watcher.includes("surface: 'task-comment'") && watcher.includes("['post_message', 'create_task_comment', 'comment_ticket']")],

package/src/codex-mcp-proxy.mjs

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url'
 import { WORK_SESSION_TOOL, runtimeControlTools, requestWorkSession } from './runtime-control.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
 import { contextTools, contextToolNames, callContextService, validateContextArguments } from './context-tools.mjs'
+import { validateAgentToolArguments, withAgentToolPolicy } from './tool-policy.mjs'
 
 export function toolWithoutCredentialInputs(tool) {
   const copy = structuredClone(tool)
@@ -17,7 +18,7 @@ export function toolWithoutCredentialInputs(tool) {
       schema.required = schema.required.filter((name) => name !== 'agent_api_key' && name !== 'agent_identifier')
     }
   }
-  return copy
+  return withAgentToolPolicy(copy)
 }
 
 export function toolAllowed(name, { disabled = new Set(), allowed = null } = {}) {
@@ -146,16 +147,17 @@ export function runCodexMcpProxy() {
           }
           reply(id, { content: [{ type: 'text', text: JSON.stringify(data) }] }); return
         }
+        const toolArguments = validateAgentToolArguments(name, request.params?.arguments || {})
         let result
-        try { result = await client.callTool(name, request.params?.arguments || {}) }
+        try { result = await client.callTool(name, toolArguments) }
         catch (error) {
           // An allowlisted coordination mutation still must never be replayed
           // after an ambiguous timeout. Retry only idempotent reads.
           if (!(allowedTools instanceof Set) || !allowedTools.has(name) || !/^(?:list_|get_|codebase_tree$)/.test(name)) throw error
-          result = await client.callTool(name, request.params?.arguments || {})
+          result = await client.callTool(name, toolArguments)
         }
         if (localContext.length && ['list_message_thread', 'post_message'].includes(name) && !result?.isError) {
-          try { await callContextService(contextEnvironment, { action: 'observe', name, args: request.params?.arguments || {}, result }, 1000) }
+          try { await callContextService(contextEnvironment, { action: 'observe', name, args: toolArguments, result }, 1000) }
           catch { /* optional indexing cannot fail the successful backend action */ }
         }
         reply(id, /^(?:list_agents|get_agent|get_agent_details)$/.test(name) ? agentResultWithoutCredentials(result) : result)

package/src/events.mjs

@@ -55,6 +55,25 @@ export function taskBelongsToAgent(task, { id, identifier } = {}) {
   return !!identifier && assignedIdentifier != null && String(assignedIdentifier) === String(identifier)
 }
 
+// A task's `agent_id` is its owner, not the author of a task update. Only
+// explicit actor fields can prove that an incoming task event came from this
+// agent. This distinction prevents an assigned agent from treating every task
+// update as self-authored while still suppressing its own status mutations.
+export function taskEventSenderIsSelf(payload, identity = {}) {
+  if (!payload || typeof payload !== 'object') return false
+  const envelopes = [payload, payload.data, payload.payload, payload.task, payload.data?.task, payload.payload?.task]
+    .filter((value) => value && typeof value === 'object' && !Array.isArray(value))
+  for (const source of envelopes) {
+    const actor = [source.actor_agent, source.actorAgent, source.updated_by_agent, source.updatedByAgent, source.changed_by_agent, source.changedByAgent, source.sender_agent, source.senderAgent, source.author_agent, source.authorAgent]
+      .find((value) => value && typeof value === 'object' && !Array.isArray(value))
+    const actorId = source.actor_agent_id ?? source.actorAgentId ?? source.updated_by_agent_id ?? source.updatedByAgentId ?? source.changed_by_agent_id ?? source.changedByAgentId ?? source.sender_agent_id ?? source.senderAgentId ?? source.author_agent_id ?? source.authorAgentId
+    const actorIdentifier = source.actor_agent_identifier ?? source.actorAgentIdentifier ?? source.updated_by_agent_identifier ?? source.updatedByAgentIdentifier ?? source.sender_agent_identifier ?? source.senderAgentIdentifier ?? source.author_agent_identifier ?? source.authorAgentIdentifier
+    if (!actor && actorId == null && actorIdentifier == null) continue
+    if (messageSenderIsSelf({ senderAgent: actor || { id: actorId, identifier: actorIdentifier }, sender_agent_id: actorId, sender_identifier: actorIdentifier }, identity)) return true
+  }
+  return false
+}
+
 // Backend task ids are database plumbing. Teammates identify tickets by the
 // project-scoped slug shown on the board (for example, OVS-57). Never synthesize
 // a slug from the numeric id: if an older backend omits it, human-facing copy
@@ -415,12 +434,12 @@ export function normalizeRenderedMessageText(value) {
 export function messageSenderIsSelf(row, identity = {}) {
   if (!row || typeof row !== 'object') return false
   const sender = [row.taskSender, row.task_sender, row.sender, row.user, row.author, row.member].find((item) => item && typeof item === 'object') || {}
-  const expanded = [row.taskSenderAgent, row.task_sender_agent, row.senderAgent, row.sender_agent, row.agent, sender.agent].find((item) => item && typeof item === 'object')
+  const expanded = [row.taskSenderAgent, row.task_sender_agent, row.senderAgent, row.sender_agent, row.authorAgent, row.author_agent, row.actorAgent, row.actor_agent, row.createdByAgent, row.created_by_agent, row.agent, sender.agent].find((item) => item && typeof item === 'object')
   const senderKind = String(sender.type ?? sender.kind ?? sender.sender_type ?? row.sender_type ?? row.author_type ?? '').toLowerCase()
   const senderLooksLikeAgent = agentSenderKind(senderKind) || (!humanSenderKind(senderKind) && (sender.agent_id != null || sender.identifier != null || (sender.slug != null && !sender.email)))
   const agent = expanded || (senderLooksLikeAgent ? sender : {})
-  const agentId = agent.id ?? agent.agent_id ?? row.agent_id ?? row.sender_agent_id ?? row.senderAgentId
-  const identifier = String(agent.identifier ?? agent.slug ?? row.agent_identifier ?? row.sender_identifier ?? '')
+  const agentId = agent.id ?? agent.agent_id ?? row.agent_id ?? row.sender_agent_id ?? row.senderAgentId ?? row.task_sender_agent_id ?? row.taskSenderAgentId ?? row.author_agent_id ?? row.authorAgentId ?? row.actor_agent_id ?? row.actorAgentId ?? row.created_by_agent_id ?? row.createdByAgentId
+  const identifier = String(agent.identifier ?? agent.slug ?? row.agent_identifier ?? row.sender_identifier ?? row.task_sender_agent_identifier ?? row.taskSenderAgentIdentifier ?? row.author_agent_identifier ?? row.authorAgentIdentifier ?? row.actor_agent_identifier ?? row.actorAgentIdentifier ?? '')
   const name = String(agent.name ?? agent.display_name ?? (senderLooksLikeAgent ? sender.name : '') ?? '')
   const aliases = new Set([identity.identifier, identity.slug, identity.name].map((item) => String(item || '').toLowerCase()).filter(Boolean))
   const stableAliases = new Set([identity.identifier, identity.slug].map((item) => String(item || '').toLowerCase()).filter(Boolean))
@@ -501,7 +520,7 @@ function conversationMentions(value, selfAliases) {
 
 export function messageSenderIsAgent(message) {
   const m = message && typeof message === 'object' ? message : {}
-  if (m.taskSenderAgent || m.task_sender_agent || m.senderAgent || m.sender_agent || m.agent || m.agent_id != null || m.sender_agent_id != null || m.senderAgentId != null) return true
+  if (m.taskSenderAgent || m.task_sender_agent || m.senderAgent || m.sender_agent || m.authorAgent || m.author_agent || m.actorAgent || m.actor_agent || m.createdByAgent || m.created_by_agent || m.agent || m.agent_id != null || m.sender_agent_id != null || m.senderAgentId != null || m.task_sender_agent_id != null || m.taskSenderAgentId != null || m.task_sender_agent_identifier != null || m.taskSenderAgentIdentifier != null || m.author_agent_id != null || m.authorAgentId != null || m.actor_agent_id != null || m.actorAgentId != null || m.created_by_agent_id != null || m.createdByAgentId != null) return true
   const sender = [m.taskSender, m.task_sender, m.sender, m.user, m.author, m.member].find((item) => item && typeof item === 'object') || {}
   if (sender.agent && typeof sender.agent === 'object') return true
   const kind = String(sender.type ?? sender.kind ?? sender.sender_type ?? m.sender_type ?? m.author_type ?? '').toLowerCase()

package/src/tool-policy.mjs

@@ -0,0 +1,100 @@
+const TASK_MUTATION_TOOLS = new Set(['create_ticket', 'update_ticket', 'create_task', 'update_task'])
+
+const TEXT_LIMITS = {
+  post_message: { fields: ['content', 'text', 'message', 'body'], max: 1200, label: 'Channel messages' },
+  create_task_comment: { fields: ['content', 'text', 'message', 'body'], max: 1200, label: 'Task comments' },
+  comment_ticket: { fields: ['content', 'text', 'message', 'body'], max: 1200, label: 'Task comments' },
+  create_ticket: { fields: ['description'], max: 2400, label: 'Task descriptions' },
+  update_ticket: { fields: ['description'], max: 2400, label: 'Task descriptions' },
+  create_task: { fields: ['description'], max: 2400, label: 'Task descriptions' },
+  update_task: { fields: ['description'], max: 2400, label: 'Task descriptions' },
+}
+
+const OWNERSHIP_GUIDANCE = 'Task ownership fields are different: assignee_id is only for a human user/member id; agent_id is only for a registered coding agent id. Never put an agent id in assignee_id. Set at most one of these fields and clear the other when changing owner type.'
+const CONCISE_GUIDANCE = 'Keep this text compact and easy to scan. Lead with the result or request, omit repeated context, and avoid open-ended invitations.'
+
+function appendDescription(value, guidance) {
+  const current = String(value || '').trim()
+  return current.includes(guidance) ? current : [current, guidance].filter(Boolean).join(' ')
+}
+
+function stringBranches(schema) {
+  if (!schema || typeof schema !== 'object') return []
+  return [schema, ...(Array.isArray(schema.anyOf) ? schema.anyOf : []), ...(Array.isArray(schema.oneOf) ? schema.oneOf : [])]
+    .filter((item) => item && typeof item === 'object' && (item.type === 'string' || !item.type))
+}
+
+function setStringLimit(schema, max, guidance = CONCISE_GUIDANCE) {
+  if (!schema || typeof schema !== 'object') return
+  schema.description = appendDescription(schema.description, `${guidance} Maximum ${max} characters.`)
+  for (const branch of stringBranches(schema)) {
+    if (branch.type === 'string') branch.maxLength = Math.min(Number.isFinite(branch.maxLength) ? branch.maxLength : max, max)
+  }
+}
+
+export function withAgentToolPolicy(tool) {
+  const copy = structuredClone(tool)
+  const name = String(copy?.name || '')
+  const schemas = [copy.inputSchema, copy.input_schema].filter((schema) => schema && typeof schema === 'object')
+
+  if (TASK_MUTATION_TOOLS.has(name)) {
+    copy.description = appendDescription(copy.description, OWNERSHIP_GUIDANCE)
+    for (const schema of schemas) {
+      const properties = schema.properties && typeof schema.properties === 'object' ? schema.properties : {}
+      if (properties.assignee_id) properties.assignee_id.description = appendDescription(properties.assignee_id.description, 'Human user/member id only. Never use an agent id here.')
+      if (properties.agent_id) properties.agent_id.description = appendDescription(properties.agent_id.description, 'Registered agent id only. Never use a human user id here.')
+    }
+  }
+
+  const limit = TEXT_LIMITS[name]
+  if (limit) {
+    copy.description = appendDescription(copy.description, `${limit.label} must be concise. Maximum ${limit.max} characters.`)
+    for (const schema of schemas) {
+      const properties = schema.properties && typeof schema.properties === 'object' ? schema.properties : {}
+      for (const field of limit.fields) if (properties[field]) setStringLimit(properties[field], limit.max)
+      if (TASK_MUTATION_TOOLS.has(name) && properties.title) setStringLimit(properties.title, 160, 'Use a short, specific title.')
+    }
+  }
+  return copy
+}
+
+const present = (value) => value !== undefined && value !== null && value !== ''
+
+export function validateAgentToolArguments(name, args = {}) {
+  const tool = String(name || '')
+  const input = args && typeof args === 'object' && !Array.isArray(args) ? args : {}
+  if (TASK_MUTATION_TOOLS.has(tool) && present(input.assignee_id) && present(input.agent_id)) {
+    throw new Error(`${OWNERSHIP_GUIDANCE} This call supplied both fields; choose the intended owner and retry once.`)
+  }
+  const limit = TEXT_LIMITS[tool]
+  if (limit) {
+    for (const field of limit.fields) {
+      if (!present(input[field])) continue
+      const length = String(input[field]).length
+      if (length > limit.max) throw new Error(`${limit.label} must be ${limit.max} characters or fewer; ${field} was ${length}. Rewrite it as a short result, request, or decision and retry once.`)
+    }
+  }
+  if (TASK_MUTATION_TOOLS.has(tool) && present(input.title) && String(input.title).length > 160) {
+    throw new Error(`Task titles must be 160 characters or fewer; title was ${String(input.title).length}. Shorten it and retry once.`)
+  }
+  return input
+}
+
+export function compactAgentMessage(value, { maxChars = 1200 } = {}) {
+  const text = String(value || '').replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()
+  if (!text || text.length <= maxChars) return text
+  const suffix = '\n\n[Shortened for readability. Full output remains in Agent Studio.]'
+  const budget = Math.max(1, maxChars - suffix.length)
+  const candidate = text.slice(0, budget)
+  const minimum = Math.floor(budget * 0.65)
+  const stops = [candidate.lastIndexOf('\n\n'), candidate.lastIndexOf('. '), candidate.lastIndexOf('! '), candidate.lastIndexOf('? '), candidate.lastIndexOf(' ')]
+  const stop = stops.find((index) => index >= minimum)
+  return `${candidate.slice(0, stop >= minimum ? stop + (candidate[stop] === '.' || candidate[stop] === '!' || candidate[stop] === '?' ? 1 : 0) : budget).trimEnd()}${suffix}`
+}
+
+export const agentToolPolicy = Object.freeze({
+  ownershipGuidance: OWNERSHIP_GUIDANCE,
+  channelMessageMaxChars: TEXT_LIMITS.post_message.max,
+  taskCommentMaxChars: TEXT_LIMITS.create_task_comment.max,
+  taskDescriptionMaxChars: TEXT_LIMITS.create_ticket.max,
+})

package/src/watch.mjs

@@ -10,12 +10,13 @@ import { fileURLToPath } from 'node:url'
 import { join, dirname } from 'node:path'
 import { OV_DIR, DEFAULT_WORKSPACE, readConfig, writeJson, configPath, onPath, fail, ok, info, slugify, stripSlash, chmodSafe } from './lib.mjs'
 import { connectAgentWs, assertWebSocket } from './ws.mjs'
-import { buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, conversationAsksPendingTickets, conversationCreatesTicket, conversationNeedsCode, conversationRequestsChannelMessage, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsAgent, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskCommentFromEvent, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
+import { buildTaskCompletionReport, claudeEventEvidence, classifyConversationTarget, conversationAsksPendingTickets, conversationCreatesTicket, conversationNeedsCode, conversationRequestsChannelMessage, failedTaskRevisionIsCurrent, mentionDedupeKeys, messageParentId, messageSenderIsAgent, messageSenderIsSelf, normalizeRenderedMessageText, renderedAgentMessages, taskAgentId, taskAgentIdentifier, taskBelongsToAgent, taskCommentFromEvent, taskEventSenderIsSelf, taskFromEvent, taskIsAwaitingReview, taskIsCompleted, taskIsCoordinationOnly, taskRevision, ticketDisplaySlug } from './events.mjs'
 import { WORK_SESSION_TOOL, workSessionRequest, agentProfileContext } from './runtime-control.mjs'
 import { createMastraMemory } from './memory.mjs'
 import { createContextService } from './context-service.mjs'
 import { contextToolGuide } from './context-tools.mjs'
 import { toolWithoutCredentialInputs } from './codex-mcp-proxy.mjs'
+import { compactAgentMessage } from './tool-policy.mjs'
 import { repositoryHasPrPushAuthorization, configurePrPublishing } from './pr-push.mjs'
 import { createMcpHttpClient } from './mcp-http.mjs'
 import { createCycleQueue } from './cycle-queue.mjs'
@@ -85,9 +86,12 @@ const REPLY_DISCIPLINE = [
   '  • BE SURE BEFORE YOU SPEAK. Do not claim something is possible, done, or broken until you have actually verified it — call the tool, read the code, check the real state. Be willing to disagree or revise a conclusion when evidence changes. If you are unsure, investigate and distinguish a finding from an assumption.',
   '  • USE RECALL, NEVER INVENT IT. Before answering a context-dependent question, search the visible thread and use any available history, search, docs, or recall tools. Reuse verified context instead of asking the user to repeat it. If no record exists, say plainly "I don\'t have a record of that". Never fabricate past events, conversations, results, links, PR numbers, deploy URLs, or figures.',
   '  • LOOK UP ASSIGNED WORK. If someone says they assigned you a task, asks which task is yours, or asks for its status, check the live board yourself with list_projects + list_tasks and then get_ticket as needed. Use list_agents only if assignment data requires a numeric identity lookup. Match assignments to your authenticated agent identity. Do not ask the teammate for a project slug, ticket slug, or numeric id before trying those MCP tools; ask only if the live lookup fails or returns genuinely ambiguous matches.',
+  '  • ASSIGNEE IDS ARE HUMAN IDS. On task mutations, assignee_id means a human user/member. agent_id means a registered agent. Never put an agent id in assignee_id, never put a human id in agent_id, and never send both. To assign work to yourself or another agent, resolve the registered agent and use agent_id.',
   '  • TICKET SLUGS, NEVER DATABASE IDS. In every human-facing channel message, ticket comment, PR description, summary, blocker, and result, reference a ticket by the exact project-scoped slug returned by get_ticket/list_tasks (for example, `OVS-57`). Numeric project_id and ticket_id values are internal MCP arguments only: never write `#57`, `ticket 57`, or expose a database id to teammates. If the backend omits the slug, use the ticket title or say “the ticket”; do not invent a slug.',
   '  • CLOSE CONCERNS. Never leave a concern, direct question, correction, or blocker addressed to you without a clear response. Acknowledge the concern, act if you can, then report the verified result. If blocked, name the blocker and the exact next action or owner in one message.',
   '  • HONOR CHANNEL DESTINATIONS. Reply to an existing request in its original thread. When a teammate explicitly asks you to send, post, announce, or share something in another channel, resolve that exact destination from live list_channels and post there. Use your dedicated agent channel for fresh top-level results, blockers, and introductions only when no other destination was requested. Never invent a channel id or silently substitute a different channel.',
+  '  • KEEP MESSAGES COMPACT. Lead with the answer, result, decision, or blocker. Default to 1-4 short sentences or at most 6 brief bullets, normally under 600 characters and never over 1,200. Do not restate the prompt, narrate routine tool use, dump raw logs, or repeat context already visible in the thread. Task descriptions may use up to 2,400 characters when acceptance details require it.',
+  '  • END AGENT-TO-AGENT TURNS. Answer one concrete peer-agent request once, without a reciprocal question, invitation, thank-you exchange, or status echo. Then wait for a human or a genuinely new human-directed request. Do not keep a conversation alive merely because another agent replied.',
   '  • WRITE PLAINLY. Prefer short sentences, commas, periods, and colons. Avoid em dashes except when reproducing quoted text.',
 ].join('\n')
 
@@ -1015,14 +1019,19 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     // reached the server, so never try another comment endpoint after an error.
     const name = names.has('create_task_comment') ? 'create_task_comment' : names.has('comment_ticket') ? 'comment_ticket' : ''
     if (!name) return { called: false, reason: 'not-advertised' }
+    const message = compactAgentMessage(content, { maxChars: 1200 })
     const args = {
       project_id: projectId,
       ticket_id: ticketId,
       ...(name === 'create_task_comment'
-        ? { content, ...(validBackendId(parentId) ? { parent_id: Number(parentId) } : {}) }
-        : { text: content }),
+        ? { content: message, ...(validBackendId(parentId) ? { parent_id: Number(parentId) } : {}) }
+        : { text: message }),
+    }
+    try {
+      const result = await callMcpTool(name, args)
+      memory.remember({ key: ownTaskCommentKey(projectId, ticketId, message), kind: 'task-comment', state: 'rendered', summary: message, refs: { projectId: Number(projectId), ticketId: Number(ticketId), ...(validBackendId(parentId) ? { threadId: Number(parentId) } : {}) } })
+      return { called: true, tool: name, result }
     }
-    try { return { called: true, tool: name, result: await callMcpTool(name, args) } }
     catch (e) {
       if (/\b(?:unknown|missing|unsupported) tool\b|\btool\b.*\bnot found\b/i.test(String(e?.message || e))) {
         try { await discoverMcpTools(true) } catch { /* the original error is enough */ }
@@ -1155,7 +1164,15 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     identity: () => ({ id: selfAgentId, identifier, slug, name: slug }),
     load: async (cid, root) => toolData(await callMcpTool('list_message_thread', { channel_id: Number(cid), message_id: Number(root) })),
   })
-  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false, isCancelled = () => false }) => {
+  const peerTurnKey = (surface, ...parts) => `peer-turn:${surface}:${parts.map((value) => String(value ?? '?')).join(':')}`
+  const ownTaskCommentKey = (projectId, ticketId, content) => {
+    const normalized = normalizeRenderedMessageText(content)
+    return `own-task-comment:${projectId}:${ticketId}:${normalized.length}:${normalized.slice(0, 120)}:${normalized.slice(-120)}`
+  }
+  const rememberPeerReply = (key, refs = {}) => {
+    if (key) memory.remember({ key, kind: 'peer-turn', state: 'replied', summary: 'Replied once to a peer agent; waiting for a human turn.', refs })
+  }
+  const postMessageOnce = async ({ key, channelId, parentId, projectId, content, skipIfAnyAgentReply = false, sourceKey = '', sourceMessageId, allowCancelled = false, peerLoopKey = '', isCancelled = () => false }) => {
     if (stopping) throw new Error('Watcher is stopping')
     const deliveryKey = String(key || '')
     if (parentId == null && !validBackendId(channelId)) {
@@ -1163,7 +1180,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       if (channelId == null) throw new Error('No dedicated agent channel available for a new thread')
       projectId = undefined // dedicated channels may be organization-scoped
     }
-    const message = String(content || '').trim()
+    const message = compactAgentMessage(content, { maxChars: 1200 })
     if (!deliveryKey || !validBackendId(channelId) || (parentId != null && !validBackendId(parentId)) || !message) return { posted: false, reason: 'invalid-delivery' }
     if (deliveredReplies.has(deliveryKey) || memory.has(deliveryKey, 'rendered')) {
       if (pendingReplyDeliveries.delete(deliveryKey)) persistReplay()
@@ -1186,7 +1203,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     // Store generated threaded replies before delivery. A transport outage must
     // retry the authoritative delivery check, not pay for another model turn.
     if (parentId != null) {
-      pendingReplyDeliveries.set(deliveryKey, { key, channelId, parentId, projectId, content: message, skipIfAnyAgentReply, sourceKey, sourceMessageId, allowCancelled })
+      pendingReplyDeliveries.set(deliveryKey, { key, channelId, parentId, projectId, content: message, skipIfAnyAgentReply, sourceKey, sourceMessageId, allowCancelled, peerLoopKey })
       persistReplay()
     }
     const run = (async () => {
@@ -1199,6 +1216,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
           deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
           memory.remember({ key: deliveryKey, kind: 'delivery', state: 'rendered', summary: duplicate ? message : rendered.at(-1)?.content, refs: { channelId: Number(channelId), threadId: Number(parentId) }, meta: { discoveredFromBackend: true } })
           if (sourceKey) memory.connect(deliveryKey, sourceKey, 'responds_to')
+          rememberPeerReply(peerLoopKey, { channelId: Number(channelId), threadId: Number(parentId) })
           log('message delivery ' + deliveryKey + ' already rendered — skipped')
           return { posted: false, reason: duplicate ? 'same-content-rendered' : 'agent-reply-rendered' }
         }
@@ -1223,6 +1241,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       deliveredReplies.add(deliveryKey); trimSeen(deliveredReplies); persistReplay()
       memory.remember({ key: deliveryKey, kind: 'delivery', state: 'rendered', summary: message, refs: { channelId: Number(channelId), ...(parentId != null ? { threadId: Number(parentId) } : {}), ...(Number.isFinite(Number(projectId)) ? { projectId: Number(projectId) } : {}) }, meta: { messageId: result.id ?? result.message?.id ?? null } })
       if (sourceKey) memory.connect(deliveryKey, sourceKey, 'responds_to')
+      rememberPeerReply(peerLoopKey, { channelId: Number(channelId), ...(parentId != null ? { threadId: Number(parentId) } : {}) })
       return { posted: true, result }
     })().then((result) => {
       if (pendingReplyDeliveries.delete(deliveryKey)) persistReplay()
@@ -1235,10 +1254,10 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
   // Task comments have no channel thread to inspect before delivery. Record the
   // delivery attempt before the mutation and use the comment id as the one-level
   // thread root. An ambiguous mutation error is never replayed automatically.
-  const postTaskCommentOnce = async ({ key, projectId, ticketId, parentId, content, sourceKey = '' }) => {
+  const postTaskCommentOnce = async ({ key, projectId, ticketId, parentId, content, sourceKey = '', peerLoopKey = '' }) => {
     if (stopping) throw new Error('Watcher is stopping')
     const deliveryKey = String(key || '')
-    const message = String(content || '').trim()
+    const message = compactAgentMessage(content, { maxChars: 1200 })
     if (!deliveryKey || !validBackendId(projectId) || !validBackendId(ticketId) || !validBackendId(parentId) || !message) return { posted: false, reason: 'invalid-delivery' }
     if (deliveredReplies.has(deliveryKey) || memory.has(deliveryKey, 'rendered')) {
       return { posted: false, reason: 'remembered' }
@@ -1253,7 +1272,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         throw new Error('No task-comment tool is advertised by the backend')
       }
       memory.remember({ key: deliveryKey, kind: 'delivery', state: 'rendered', summary: message, refs: { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(parentId) }, meta: { surface: 'task-comment' } })
+      memory.remember({ key: ownTaskCommentKey(projectId, ticketId, message), kind: 'task-comment', state: 'rendered', summary: message, refs: { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(parentId) } })
       if (sourceKey) memory.connect(deliveryKey, sourceKey, 'responds_to')
+      rememberPeerReply(peerLoopKey, { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(parentId) })
       return { posted: true, result: result.result }
     })().finally(() => messageDeliveries.delete(deliveryKey))
     messageDeliveries.set(deliveryKey, run)
@@ -1262,9 +1283,9 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
 
   async function publishWorkPlan(live, entries, acknowledgement = '') {
     const { control, delivery, taskRef } = live
-    const steps = (Array.isArray(entries) ? entries : []).filter(entry => entry && typeof entry.content === 'string' && entry.content.trim()).slice(0, 3).map(entry => entry.content.trim().slice(0, 240))
+    const steps = (Array.isArray(entries) ? entries : []).filter(entry => entry && typeof entry.content === 'string' && entry.content.trim()).slice(0, 3).map(entry => entry.content.trim().slice(0, 160))
     if (!steps.length || control.cancelled || !control.planKey || memory.has(control.planKey)) return
-    const introduction = String(acknowledgement || '').trim().slice(0, 1200) || (control.taskLabel ? `I'm on ${control.taskLabel}.` : "I'll take this on.")
+    const introduction = String(acknowledgement || '').trim().slice(0, 320) || (control.taskLabel ? `I'm on ${control.taskLabel}.` : "I'll take this on.")
     const content = `${introduction}\n\n${steps.map((step, index) => `${index + 1}. ${step}`).join('\n')}`
     const channelId = delivery?.channelId ?? taskRef?.channelId ?? await projectStatusChannel(taskRef?.projectId)
     if (channelId == null || control.cancelled) return
@@ -1834,6 +1855,13 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     const ticketId = hinted && (hinted.id ?? hinted.task_id ?? hinted.taskId)
     const projectId = hinted && (hinted.project_id ?? hinted.projectId ?? raw.project_id ?? raw.projectId)
     if (!validBackendId(ticketId) || !validBackendId(projectId)) { log(kind + ' missing ticket/project identity — ignored'); return }
+    if (kind === 'task:updated') {
+      try { await ensureSelfAgent() } catch { /* stable identifier may still prove authorship */ }
+      if (taskEventSenderIsSelf(raw, { id: selfAgentId, identifier, slug, name })) {
+        log(kind + ' ticket #' + ticketId + ' was updated by this agent — ignored')
+        return { status: 'ignored-self' }
+      }
+    }
     try {
       const ticketData = toolData(await callMcpTool('get_ticket', { project_id: projectId, ticket_id: ticketId }))
       const ticket = ticketData.ticket ?? ticketData.task ?? ticketData
@@ -1917,7 +1945,19 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
     }
     try { await ensureSelfAgent() }
     catch (error) { log('agent identity lookup unavailable; using configured aliases: ' + (error?.message || error)) }
+    const rootCommentId = messageParentId(comment) ?? Number(commentId)
+    if (memory.has(ownTaskCommentKey(projectId, ticketId, text), 'rendered')) {
+      log(`task:comment project=${projectId} ticket=${ticketId} matches this agent's delivered comment — ignored`)
+      return { status: 'ignored-self' }
+    }
     if (messageSenderIsSelf(comment, { id: selfAgentId, identifier, slug, name })) return { status: 'ignored-self' }
+    const peer = messageSenderIsAgent(comment)
+    const loopKey = peerTurnKey('task-comment', projectId, ticketId, rootCommentId)
+    if (peer && memory.has(loopKey, 'replied')) {
+      log(`task:comment project=${projectId} ticket=${ticketId} ignored after one peer-agent reply; waiting for a human turn`)
+      return { status: 'ignored-peer-loop' }
+    }
+    if (!peer) memory.remember({ key: loopKey, kind: 'peer-turn', state: 'human', summary: text, refs: { projectId: Number(projectId), ticketId: Number(ticketId), threadId: Number(rootCommentId) } })
     const target = classifyConversationTarget(comment, [...selfAliases], { threadOwned: true })
     if (target.action !== 'handle') {
       log('task:comment ignored before model start (' + target.reason + ')')
@@ -1939,9 +1979,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         log(`task:comment ticket #${ticketId} is not assigned to this agent — ignored`)
         return { status: 'ignored-unassigned' }
       }
-      const rootCommentId = messageParentId(comment) ?? Number(commentId)
       const who = senderName(comment)
-      const peer = messageSenderIsAgent(comment)
       const ticketSlug = ticketDisplaySlug(ticket)
       memory.remember({ key: sourceKey, kind: 'task-comment', state: 'received', summary: text, refs: { projectId: Number(projectId), ticketId: Number(ticketId), messageId: Number(commentId), threadId: Number(rootCommentId) } })
       const delivery = {
@@ -1952,6 +1990,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         parentId: Number(rootCommentId),
         sourceKey,
         watcherOwned: true,
+        peerLoopKey: peer ? loopKey : '',
       }
       const label = ticketSlug || String(ticket.title || 'the assigned ticket')
       const context = `The watcher received a new comment on your assigned ticket ${JSON.stringify(label)} from ${JSON.stringify(who || (peer ? 'another agent' : 'a teammate'))}: ${JSON.stringify(text)}. Authoritative ticket details: ${JSON.stringify({ slug: ticketSlug, title: ticket.title, description: ticket.description, priority: ticket.priority, status: ticket.type?.name ?? ticket.task_type?.name ?? ticket.status ?? ticket.state })}. Answer the comment directly in the context of this ticket. Do not call post_message or any task-comment tool; return only the final reply and the watcher will post it once in the source comment thread.${peer ? ' This was authored by another team agent. Address its concrete question or request without replacing it with ticket inventory or adding an open-ended reciprocal question.' : ''}`
@@ -2074,6 +2113,12 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
         if (!threadOwned || memory.has(sourceKey, 'received')) { log('agent:mention (dup) — skipped'); return }
         log('agent:mention replay recovered for active owned thread')
       }
+      const loopKey = cid != null && threadRoot != null ? peerTurnKey('channel', cid, threadRoot) : ''
+      if (peerMessage && loopKey && memory.has(loopKey, 'replied')) {
+        log('agent:mention ignored before model start (peer-loop-budget)')
+        return { status: 'ignored-peer-loop' }
+      }
+      if (!peerMessage && loopKey) memory.remember({ key: loopKey, kind: 'peer-turn', state: 'human', summary: text, refs: { channelId: Number(cid), threadId: Number(threadRoot) } })
       const target = classifyConversationTarget(msg, [...selfAliases], { threadOwned })
       if (target.action === 'ignore') {
         log('agent:mention ignored before model start (' + target.reason + ')')
@@ -2102,7 +2147,7 @@ export function createBackendWatcher({ backend, wsUrl, apiKey, identifier, slug,
       // redirect can cancel its process. The watcher delivers the final answer
       // for every runtime after an authoritative last-moment thread check.
       const conversationDelivery = (stage = 'reply', skipIfAnyAgentReply = stage !== 'result', allowChannelMessaging = false) => cid != null
-        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: true, allowChannelMessaging }
+        ? { key: `reply:${sourceKey}:${stage}`, channelId: Number(cid), parentId: threadRoot, skipIfAnyAgentReply, sourceKey, sourceMessageId: mid, watcherOwned: true, allowChannelMessaging, peerLoopKey: peerMessage ? loopKey : '' }
         : null
       // Under-the-hood model control from chat (view / switch the model the agent runs).
       const mcmd = cid != null ? parseModelCmd(text) : null