openvisio-agent 0.19.11 → 0.20.0

package/scenarios/workspace.scenarios.mjs

@@ -0,0 +1,324 @@
+import assert from 'node:assert/strict'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { createBackendWatcher } from '../src/watch.mjs'
+import { createByoMemoryGraph } from '../src/memory.mjs'
+
+const human = { id: 3, name: 'Daniel Adewale', email: 'daniel@example.test' }
+const self = { id: 7, identifier: 'alex', name: 'Alex', added_by: human, organization_id: 3 }
+const pr = 'https://github.com/example/workspace/pull/62'
+const completion = { subtype: 'ok', didCode: true, didRepoMutation: true, didMcpTaskRead: true, didMcpTaskUpdate: true, outputText: `Fixed and verified. PR: ${pr}` }
+const turn = () => new Promise((resolve) => setImmediate(resolve))
+
+async function eventually(predicate, description) {
+  for (let n = 0; n < 500; n++) { if (predicate()) return; await turn() }
+  assert.fail(`Watcher did not reach: ${description}`)
+}
+
+export function fixture({ agent = 'codex', task = true, run, threadError = false, commentTools = [], onComment, selfProfile = self } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), 'byo-workspace-'))
+  const posts = [], runs = [], calls = [], logs = [], messages = [], subscriptions = []
+  const ticket = { id: 77, project_id: 1, slug: 'OPEN-77', title: 'Repair the component', agent_id: 7, status: 'In Progress', type_id: 1, updated_at: 'revision-1' }
+  let watcher, messageId = 100, closed = 0
+  const memory = createByoMemoryGraph({ path: join(dir, 'ledger.json') })
+  const mcp = {
+    listTools: async () => ['list_agents', 'list_projects', 'list_tasks', 'get_ticket', 'update_ticket', 'post_message', 'list_message_thread', 'list_channels', 'list_task_types', 'list_activity', ...commentTools].map((name) => ({ name })),
+    callTool: async (name, args = {}) => {
+      calls.push({ name, args })
+      if (commentTools.includes(name)) return onComment ? await onComment(name, args) : { id: 500 }
+      if (name === 'list_agents') return { agents: [selfProfile] }
+      if (name === 'list_projects') return { projects: [{ id: 1, name: 'Workspace' }] }
+      if (name === 'list_tasks') return { tasks: task ? [{ ...ticket }] : [] }
+      if (name === 'list_task_types') return { types: [{ id: 1, name: 'In Progress' }, { id: 2, name: 'Testing' }, { id: 3, name: 'Done' }] }
+      if (name === 'get_ticket') { assert.equal(args.project_id, 1); assert.equal(args.ticket_id, 77); return { ticket: { ...ticket } } }
+      if (name === 'update_ticket') { Object.assign(ticket, args); return { ticket: { ...ticket } } }
+      if (name === 'list_channels') return { channels: [{ id: 2, name: 'alex', agent_id: 7 }, { id: 9, name: 'general' }] }
+      if (name === 'list_activity') return { activities: [] }
+      if (name === 'list_message_thread') {
+        if (typeof threadError === 'function') await threadError()
+        else if (threadError) throw new Error('Thread service unavailable')
+        return { messages: messages.filter((m) => m.channel_id === args.channel_id && (m.id === args.message_id || m.parent_id === args.message_id)) }
+      }
+      if (name === 'post_message') {
+        const posted = { ...args, id: ++messageId, sender_agent: self }
+        posts.push(posted); messages.push(posted)
+        return posted
+      }
+      throw new Error(`Unexpected MCP call ${name}`)
+    },
+  }
+  const createRunner = (options) => {
+    let cancel
+    return {
+      runCycle: async (prompt, model, runtimeOptions) => {
+        const entry = { prompt, model, runtimeOptions, options }
+        runs.push(entry)
+        if (run) return new Promise((resolve, reject) => {
+          cancel = () => resolve({ subtype: 'canceled' })
+          Promise.resolve(run(entry, { ticket, posts, messages })).then(resolve, reject)
+        })
+        if (options.workdir) {
+          Object.assign(ticket, { status: 'Testing', type_id: 2, description: `PR: ${pr}\nVerification: build passed`, updated_at: 'revision-2' })
+          return { ...completion, ...(agent !== 'codex' ? { didResultMessage: true } : {}) }
+        }
+        return { subtype: 'ok', outputText: 'I checked the current details.' }
+      },
+      cancelCurrent: async () => cancel?.(),
+      close: () => { closed++ },
+    }
+  }
+  const start = () => {
+    watcher = createBackendWatcher({ wsUrl: 'wss://unused.example.test', mcpUrl: 'https://unused.example.test/mcp', apiKey: 'test-key', identifier: 'alex', slug: 'test-alex', agent, workdir: join(dir, 'workspace'), model: 'test-code', chatModel: 'test-chat' }, {
+      stateDir: dir, memory, mcpClient: mcp, createRunner, connect: () => ({ close() {}, subscribeOrganization(id) { subscriptions.push(id) } }), autoStart: false, log: (value) => logs.push(value),
+    })
+    return watcher
+  }
+  start()
+  return {
+    dir, ticket, posts, runs, calls, logs, messages, memory, subscriptions,
+    get watcher() { return watcher },
+    get closed() { return closed },
+    set threadError(value) { threadError = value },
+    start,
+    async idle() { await eventually(() => watcher.pending === 0, 'idle queues'); await turn() },
+    async mention(content, { parent = 100, id = 200, sender = human, channel = 2 } = {}) {
+      const message = { id, parent_id: parent, channel_id: channel, content, sender }
+      messages.push(message)
+      await watcher.receive('agent:mention', { channel_id: channel, message })
+    },
+    async cleanup() { await watcher.close(); rmSync(dir, { recursive: true, force: true }) },
+  }
+}
+
+export const scenarios = []
+const scenario = (id, description, run) => scenarios.push({ id: `workspace-${id}`, category: 'integrated-watcher', description, run })
+
+for (const agent of ['codex', 'opencode', 'claude']) {
+  for (const source of ['websocket', 'reconciliation']) {
+    scenario(`assignment-${agent}-${source}`, `${agent}: ${source} assignment completes once; handoff and reconnect do not restart work`, async () => {
+      const f = fixture({ agent })
+      try {
+        if (source === 'websocket') await f.watcher.receive('task:assigned', { task: { id: 77, project_id: 1 } })
+        else await f.watcher.reconcile()
+        await f.idle()
+        assert.equal(f.runs.length, 1, f.logs.join('\n'))
+        assert.equal(f.posts.length, 1, f.logs.join('\n'))
+        assert.equal(f.posts[0].channel_id, 2)
+        assert.equal(f.posts[0].parent_id, undefined)
+        assert.match(f.posts[0].content, /OPEN-77/)
+        await f.watcher.receive('task:updated', { task: { id: 77, project_id: 1 } })
+        await f.watcher.reconcile()
+        await f.idle()
+        assert.equal(f.runs.length, 1)
+        assert.equal(f.posts.length, 1)
+        await f.watcher.close(); f.start()
+        await f.watcher.reconcile(); await f.idle()
+        assert.equal(f.runs.length, 1)
+        assert.equal(f.posts.length, 1)
+      } finally { await f.cleanup() }
+    })
+  }
+}
+
+for (const origin of ['fresh-completion', 'legacy-delivery', 'backend-root']) {
+  for (const restart of [false, true]) {
+    scenario(`repair-${origin}-${restart}`, `Repair follow-up after ${origin}, restart=${restart}, uses coding context and source thread exactly once`, async () => {
+      const f = fixture()
+      try {
+        let parent = 100
+        const rootContent = `I finished OPEN-77. PR: ${pr}`
+        if (origin === 'fresh-completion') {
+          await f.watcher.receive('task:assigned', { task: { id: 77, project_id: 1 } }); await f.idle()
+          parent = f.posts[0].id
+        } else if (origin === 'legacy-delivery') {
+          f.memory.remember({ key: 'legacy-completion', kind: 'delivery', state: 'rendered', summary: rootContent, refs: { channelId: 2 }, meta: { messageId: parent } })
+        } else f.messages.push({ id: parent, channel_id: 2, content: rootContent, sender_agent: self })
+        if (restart) { await f.watcher.close(); f.start() }
+        const beforeRuns = f.runs.length, beforePosts = f.posts.length
+        await f.mention('The build failed so run build and fix the issue.', { parent })
+        await f.idle()
+        assert.equal(f.runs.length, beforeRuns + 1, f.logs.join('\n'))
+        assert.ok(f.runs.at(-1).options.workdir)
+        assert.ok(f.runs.at(-1).prompt.includes(pr))
+        assert.equal(f.posts.length, beforePosts + 1)
+        assert.equal(f.posts.at(-1).parent_id, parent)
+        await f.mention('The build failed so run build and fix the issue.', { parent })
+        await f.idle()
+        assert.equal(f.runs.length, beforeRuns + 1)
+        assert.equal(f.posts.length, beforePosts + 1)
+      } finally { await f.cleanup() }
+    })
+  }
+}
+
+for (const request of ['@Atlas fix this', 'Thanks!', 'Stop working on this.']) {
+  scenario(`unowned-${request.replace(/\W+/g, '-')}`, `Unowned thread ${JSON.stringify(request)} cannot start coding`, async () => {
+    const f = fixture({ task: false })
+    try {
+      f.messages.push({ id: 100, channel_id: 2, content: 'Unrelated thread', sender: human })
+      await f.mention(request); await f.idle()
+      assert.equal(f.runs.length, 0)
+      assert.equal(f.posts.length, 0)
+    } finally { await f.cleanup() }
+  })
+}
+
+scenario('cancel-during-model', 'Stand-down cancels only its active work and prevents stale final delivery', async () => {
+  const f = fixture({ task: false, run: () => new Promise(() => {}) })
+  try {
+    await f.mention('@Alex fix the component tests.'); await eventually(() => f.runs.length === 1, 'coding started')
+    await f.mention('Stop working on this.', { id: 201 }); await f.idle()
+    assert.equal(f.posts.length, 1)
+    assert.match(f.posts[0].content, /standing down/)
+    assert.equal(f.posts[0].parent_id, 100)
+  } finally { await f.cleanup() }
+})
+
+scenario('close-during-intake', 'Shutdown does not accept late messages or restart a model', async () => {
+  const f = fixture({ task: false })
+  try {
+    const received = f.mention('@Alex fix the component tests.')
+    await f.watcher.close(); await received
+    await f.mention('@Alex implement the component.', { id: 202 })
+    assert.equal(f.runs.length, 0)
+    assert.equal(f.posts.length, 0)
+  } finally { await f.cleanup() }
+})
+
+scenario('known-thread-read-outage', 'Explicitly addressed message is routed even when optional root lookup fails', async () => {
+  const f = fixture({ task: false, threadError: true })
+  try {
+    await f.mention('@Alex what model are you running?'); await f.idle()
+    assert.equal(f.runs.length, 1, f.logs.join('\n'))
+    assert.equal(f.posts.length, 0, 'Unavailable authoritative delivery read must not become an unchecked post')
+    await f.watcher.close(); f.start()
+    f.threadError = false
+    await f.watcher.retryDeliveries()
+    assert.equal(f.runs.length, 1, 'Restart retries delivery without regenerating the answer')
+    assert.equal(f.posts.length, 1)
+    await f.watcher.retryDeliveries()
+    assert.equal(f.posts.length, 1)
+  } finally { await f.cleanup() }
+})
+
+for (const assignment of [
+  { agent_id: 8, agent: { identifier: 'alex' } },
+  { agent_id: 8, agent: { id: 7, identifier: 'alex' } },
+  { agent_id: null, agent: { identifier: 'atlas' } },
+]) {
+  scenario(`assignment-conflict-${scenarios.length}`, `Assignment identity ${JSON.stringify(assignment)} cannot start another agent's ticket`, async () => {
+    const f = fixture()
+    try {
+      Object.assign(f.ticket, assignment)
+      await f.watcher.receive('task:assigned', { task: { id: 77, project_id: 1 } })
+      await f.watcher.reconcile(); await f.idle()
+      assert.equal(f.runs.length, 0)
+      assert.equal(f.posts.length, 0)
+    } finally { await f.cleanup() }
+  })
+}
+
+scenario('numeric-review-report', 'Numeric-only Testing state produces the verified completion report without another model turn', async () => {
+  const f = fixture({ run: async (_, { ticket }) => {
+    delete ticket.status
+    Object.assign(ticket, { type_id: 2, description: `PR: ${pr}`, updated_at: 'review-2' })
+    return completion
+  } })
+  try {
+    await f.watcher.receive('task:assigned', { task: { id: 77, project_id: 1 } }); await f.idle()
+    assert.equal(f.runs.length, 1)
+    assert.equal(f.posts.length, 1, f.logs.join('\n'))
+    await f.watcher.reconcile(); await f.idle()
+    assert.equal(f.runs.length, 1)
+  } finally { await f.cleanup() }
+})
+
+scenario('distinct-source-identical-text', 'Different human message ids with identical text remain distinct requests', async () => {
+  const f = fixture({ task: false })
+  try {
+    await f.mention('@Alex what model are you running?', { id: 200 }); await f.idle()
+    await f.mention('@Alex what model are you running?', { id: 201 }); await f.idle()
+    assert.equal(f.runs.length, 2)
+    assert.equal(f.posts.length, 2)
+  } finally { await f.cleanup() }
+})
+
+scenario('cancel-pending-then-reactivate', 'New request in a canceled thread cannot resurrect its older pending answer', async () => {
+  const f = fixture({ task: false, threadError: true })
+  try {
+    await f.mention('@Alex what model are you running?'); await f.idle()
+    assert.equal(f.runs.length, 1)
+    await f.mention('Stop working on this.', { id: 201 }); await f.idle()
+    f.threadError = false
+    await f.mention('@Alex check the current project details.', { id: 202 }); await f.idle()
+    await f.watcher.retryDeliveries()
+    assert.equal(f.runs.length, 2)
+    // Final response to the new question plus at most its stand-down confirmation.
+    assert.equal(f.posts.filter((post) => !/standing down/.test(post.content)).length, 1)
+  } finally { await f.cleanup() }
+})
+
+scenario('close-during-delivery-read', 'Close waits for in-flight delivery reads and prevents a late post', async () => {
+  let release, started = false
+  const f = fixture({ task: false })
+  try {
+    f.memory.remember({ key: 'own-root:2:100', kind: 'thread', state: 'authored', refs: { channelId: 2, threadId: 100 }, meta: { rootContent: 'I am here.' } })
+    f.threadError = () => new Promise((resolve) => { started = true; release = resolve })
+    await f.mention('@Alex check the current project details.')
+    await eventually(() => started, 'delivery read starts')
+    let finished = false
+    const closing = f.watcher.close().then(() => { finished = true })
+    await turn()
+    assert.equal(finished, false)
+    release(); await closing
+    assert.equal(f.posts.length, 0)
+    assert.equal(f.watcher.pending, 0)
+  } finally { await f.cleanup() }
+})
+
+for (const value of [null, '', 0, -1, 'NaN', 'abc', '9007199254740993']) {
+  for (const field of ['channel', 'id', 'parent']) {
+    if (field === 'parent' && value == null) continue
+    scenario(`invalid-${field}-${String(value) || 'empty'}`, `Invalid ${field}=${JSON.stringify(value)} starts no model and makes no post`, async () => {
+      const f = fixture({ task: false })
+      try {
+        await f.mention('@Alex fix the component.', { [field]: value }); await f.idle()
+        assert.equal(f.runs.length, 0)
+        assert.equal(f.posts.length, 0)
+      } finally { await f.cleanup() }
+    })
+  }
+}
+
+for (const parentField of ['parent_id', 'parentId', 'thread_id', 'threadId', 'reply_to', 'replyTo']) {
+  for (const idField of ['id', 'message_id', 'messageId']) {
+    scenario(`thread-envelope-${parentField}-${idField}`, `Untagged repair uses ${parentField}/${idField} and a numeric-only root author before startup reconciliation`, async () => {
+      const f = fixture({ task: false })
+      try {
+        f.messages.push({ id: 100, channel_id: 2, content: `PR: ${pr}`, sender_agent: { id: 7 } })
+        await f.watcher.receive('agent:mention', { channelId: 2, message: { [idField]: 200, [parentField]: 100, content: 'The build failed so run build and fix the issue.', sender: human } })
+        await f.idle()
+        assert.equal(f.runs.length, 1, f.logs.join('\n'))
+        assert.ok(f.runs[0].options.workdir)
+        assert.equal(f.posts.length, 1)
+        assert.equal(f.posts[0].parent_id, 100)
+      } finally { await f.cleanup() }
+    })
+  }
+}
+
+for (const question of ['@Alex do you have pending tickets?', '@Alex can you check if you have pending tasks?', '@Alex just list my pending tickets, do not start work.']) {
+  scenario(`pending-discovery-${scenarios.length}`, `Pending discovery follows the explicit start/status contract for ${JSON.stringify(question)}`, async () => {
+    const f = fixture()
+    try {
+      await f.mention(question)
+      await eventually(() => f.calls.some((call) => call.name === 'list_tasks'), 'pending list read')
+      // Discovery dispatch is asynchronous; let the complete routing chain enter the queue.
+      for (let n = 0; n < 12; n++) await turn()
+      await f.idle()
+      const statusOnly = question.includes('do not start')
+      assert.equal(f.runs.filter((run) => run.options.workdir).length, statusOnly ? 0 : 1, f.logs.join('\n'))
+    } finally { await f.cleanup() }
+  })
+}

package/scripts/certify.mjs

@@ -13,8 +13,9 @@ function run(label, command, args, cwd = root) {
   else process.stdout.write(`✓ ${label}\n`)
 }
 
-for (const file of readdirSync(join(root, 'src')).filter((name) => name.endsWith('.mjs'))) run(`syntax ${file}`, process.execPath, ['--check', join(root, 'src', file)])
-for (const file of readdirSync(join(root, 'bin')).filter((name) => name.endsWith('.mjs'))) run(`syntax ${file}`, process.execPath, ['--check', join(root, 'bin', file)])
+for (const directory of ['src', 'bin', 'studio']) {
+  for (const file of readdirSync(join(root, directory)).filter((name) => name.endsWith('.mjs'))) run(`syntax ${directory}/${file}`, process.execPath, ['--check', join(root, directory, file)])
+}
 run('unit and behavior tests', process.execPath, ['--test'])
 run('frontend typecheck', 'npm', ['run', 'typecheck'], join(repo, 'frontend'))
 run('package dry run', 'npm', ['pack', '--dry-run'])
@@ -56,15 +57,18 @@ const assertions = [
   ['assigned coding completion is posted by the watcher', watcher.includes('announceTaskCompletion') && watcher.includes('postMessageOnce({ key: `completion:${report.key}`')],
   ['completion requires review/done state and PR evidence', watcher.includes('buildTaskCompletionReport') && watcher.includes('completion report deferred')],
   ['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("callOptionalMcpTool('comment_ticket', { project_id: projectId, ticket_id: ticketId, text: report.content })") && watcher.includes('comment_ticket is not exposed; completing ticket') && watcher.includes('reportedTaskComments: [...reportedTaskComments]') && watcher.includes('reportedTaskComments.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' ? { content } : { text: content }")],
+  ['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 and activity mention delivery share a replay guard', watcher.includes('markMentionHandled(activityMessage, activityChannelId)') && watcher.includes('markMentionHandled(msg, cid)') && watcher.includes('recentMentionSignatures')],
   ['reconciled mentions reuse the guarded websocket delivery path', watcher.includes("onEvent('agent:mention'") && watcher.includes('_mentionAlreadyMarked: true')],
   ['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("reason: 'owned-thread-follow-up'") && events.includes("reason: 'explicit-other-recipient'") && events.includes("reason: 'other-agent-chatter'")],
   ['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')],
-  ['reconciliation recovers untagged human follow-ups in owned threads', watcher.includes("memory.has(activityControlKey, 'active')") && watcher.includes('const addressedActivity = mentionNeedles.some') && watcher.includes("!ownedActivity || memory.has(activitySourceKey, 'received')")],
-  ['coding mentions require an action and concrete repository target', watcher.includes('conversationNeedsCode(text)') && events.includes('const action =') && events.includes('const target =')],
+  ['reconciliation recovers untagged human follow-ups in owned threads', watcher.includes("memory.has(activityControlKey, 'active')") && watcher.includes('const addressedActivity = mentionNeedles.some') && watcher.includes("memory.has(activitySourceKey, 'received')")],
+  ['coding mentions require an action and concrete repository target', watcher.includes('conversationNeedsCode(text, { rootContent:') && events.includes('const action =') && events.includes('const target =')],
+  ['agent-authored roots establish ownership and legacy roots are verified before routing', watcher.includes('saveOwnThread(channelId, postedId, message)') && watcher.includes('await resolveOwnThread(cid, parent)') && watcher.includes('_threadRootContent: rootContent')],
   ['stand-down and redirects cancel only source-thread workers', watcher.includes('cancelThread(cid, threadRoot') && watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent') && watcher.includes("subtype === 'canceled'")],
   ['thread cancellation is rechecked immediately before watcher delivery', watcher.includes('const newlyCancelled = suppressCancelled()') && watcher.includes('if (newlyCancelled) return newlyCancelled')],
   ['generic coding pickup messages are absent', !watcher.includes("I've picked this up and will return here with the verified result")],
@@ -79,10 +83,10 @@ const assertions = [
   ['queued assignments are checked again before model execution', watcher.includes('queued ticket no longer actionable; skipped before model start')],
   ['feature titles cannot be mistaken for coordination commands', watcher.includes('taskIsCoordinationOnly(taskText)') && events.includes('Uploading files as messages') && events.includes('explicitCoordination')],
   ['reply runner has no coding workspace or coding charter', watcher.includes("workdir: ''") && watcher.includes("systemPrompt: CHAT_CHARTER + '\\n\\n' + credNote") && opencodeConfig.includes("'*': 'deny'")],
-  ['MCP requests have a deadline including response bodies', mcpHttp.includes('controller.abort()') && mcpHttp.includes('const body = await res.text()')],
+  ['MCP requests have a deadline including response bodies', mcpHttp.includes('controller.abort()') && mcpHttp.includes('res.text()')],
   ['Mastra memory uses real ticket and thread identities', watcher.includes('createMastraMemory') && watcher.includes('await memory.context(memoryRefs)') && memory.includes('new Memory({ storage') && memory.includes('new LibSQLStore') && memory.includes('ticket:${refs.projectId}:${refs.ticketId}') && memory.includes('channel:${refs.channelId}:thread:')],
   ['Codex and OpenCode use warm scoped Mastra ACP sessions', watcher.includes('createMastraAcpRunner') && watcher.includes('workRunners.acquire(sessionKey') && watcher.includes('replyRunners.acquire(key') && mastraHarness.includes('persistSession: true')],
-  ['runtime models are selected explicitly before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('await acp.setModel(resolution.selected)') && modelSelection.includes('automatic model substitution is disabled') && watcher.includes('if (changed) persistModel()')],
+  ['runtime models are selected explicitly before work starts', mastraHarness.includes('getAvailableModels()') && mastraHarness.includes('resolveAvailableModel(requestedModel') && mastraHarness.includes('acp.setModel(resolution.selected)') && modelSelection.includes('automatic model substitution is disabled') && watcher.includes('if (changed) persistModel()')],
   ['one watcher owns bounded work and per-thread reply sessions', watcher.includes('MAX_CONCURRENT_WORKERS = 3') && watcher.includes('workRunners.release(sessionKey)') && watcher.includes('replyRunners.release(key)') && watcher.includes('groupKey: (item) => item.taskRef')],
   ['workers serialize shared worktrees while independent worktrees run concurrently', watcher.includes('groupKey: (item) => item.workdir || workdir') && cycleQueue.includes('active.size < concurrency') && cycleQueue.includes('activeGroups.has(candidate[1].group)')],
   ['work and reply cancellation targets are isolated', watcher.includes('item.control.cancelled = true') && watcher.includes('item.control.runner?.cancelCurrent')],
@@ -130,7 +134,7 @@ const assertions = [
   ['private PR pushes use an explicit constrained helper', cli.includes("cmd === 'authorize-pr-push'") && cli.includes("cmd === 'push-pr-branch'") && prPush.includes("'push', '-u', identity.remote, destination")],
   ['PR push helper restricts branch and destination within setup authority', prPush.includes('isSafeAgentBranch(branch)') && prPush.includes('policyAllows(') && prPush.includes('accepts no force, remote, or ref args')],
   ['Codex recognizes helper authorization as a blocker', events.includes('OPENVISIO_PR_PUSH_AUTH_REQUIRED') && watcher.includes("block?.kind === 'pr-push-authorization-required'")],
-  ['policy blocker is surfaced to the user', watcher.includes('reportPolicyBlock(prompt, activeTaskRef, result.policyBlock, delivery)') && watcher.includes("Action required: I'm blocked")],
+  ['policy blocker is surfaced to the user', watcher.includes('reportPolicyBlock(prompt, activeTaskRef, result.policyBlock, delivery)') && watcher.includes("The local runtime rejected")],
   ['blocker routing carries explicit task identity', watcher.includes('const activeTaskRef = taskRef') && watcher.includes('taskRef: activeTaskRef')],
   ['reply discovery failures stay scoped while failed mutations fail closed', watcher.includes('blockingReplyMcpErrors(result?.mcpErrors)') && watcher.includes('preserving the scoped model reply') && events.includes('export function blockingReplyMcpErrors')],
   ['pending-ticket questions use watcher-owned MCP reads without a chat model cycle', watcher.includes('conversationAsksPendingTickets(text)') && watcher.includes('pending-ticket question -> watcher-owned MCP lookup') && watcher.includes("callMcpReadWithRetry('list_tasks'") && watcher.includes("if (selfAgentId == null) {\n      const agentsData = toolData(await callMcpReadWithRetry('list_agents'))")],

package/scripts/run-scenarios.mjs

@@ -0,0 +1,32 @@
+import { writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { scenarios, validateCatalogue } from '../scenarios/index.mjs'
+
+validateCatalogue()
+const reportIndex = process.argv.indexOf('--report')
+const listOnly = process.argv.includes('--list')
+const results = []
+const started = performance.now()
+for (const scenario of scenarios) {
+  const { run, ...metadata } = scenario
+  if (listOnly) { results.push(metadata); continue }
+  const start = performance.now()
+  try {
+    await run()
+    results.push({ ...metadata, status: 'passed', durationMs: Math.round((performance.now() - start) * 100) / 100 })
+  } catch (error) {
+    results.push({ ...metadata, status: 'failed', error: String(error?.stack || error) })
+    process.stderr.write(`FAIL ${scenario.id}: ${error?.message || error}\n`)
+  }
+}
+const categories = {}
+for (const row of results) categories[row.category] = (categories[row.category] || 0) + 1
+const failed = results.filter((row) => row.status === 'failed').length
+const report = { generatedAt: new Date().toISOString(), node: process.version, total: results.length, passed: listOnly ? undefined : results.length - failed, failed: listOnly ? undefined : failed, durationMs: Math.round(performance.now() - started), categories, scenarios: results }
+if (reportIndex !== -1) {
+  if (!process.argv[reportIndex + 1]) throw new Error('--report requires a filename')
+  writeFileSync(resolve(process.argv[reportIndex + 1]), JSON.stringify(report, null, 2) + '\n')
+}
+if (listOnly && reportIndex === -1) process.stdout.write(JSON.stringify(report, null, 2) + '\n')
+else process.stdout.write(`${results.length} scenarios: ${results.length - failed} passed, ${failed} failed. ${report.durationMs}ms\n${JSON.stringify(categories)}\n`)
+process.exitCode = failed ? 1 : 0

package/src/agent-journal.mjs

@@ -0,0 +1,138 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { constants } from 'node:fs'
+import { chmod, lstat, mkdir, open, rename, stat, unlink } from 'node:fs/promises'
+import { join } from 'node:path'
+
+const MAX_FILE_BYTES = 1024 * 1024
+const MAX_PENDING_BYTES = 256 * 1024
+const MAX_EVENT_BYTES = 32 * 1024
+const OMIT = /^(?:apikey|agentapikey|key|password|passwordhash|secret|clientsecret|token|accesstoken|refreshtoken|authorization|cookie|setcookie|env|envvars|environment|environmentvariables|processenv|rawenv|rawinput|rawoutput|reasoning|thoughts?|thinking|chainofthought)$/i
+export const isPrivateThoughtEvent = (type) => /(?:reasoning|thought|thinking)/i.test(String(type || ''))
+
+// Keep the journal suitable for direct local display. It records explicit plans,
+// observable tools and public output, never provider reasoning or raw envelopes.
+export function sanitizeJournalData(value, { secrets = [] } = {}) {
+  const known = secrets.filter((secret) => typeof secret === 'string' && secret).sort((a, b) => b.length - a.length)
+  const seen = new WeakSet()
+  let visited = 0
+  const cleanString = (text) => {
+    let result = text
+    for (const secret of known) result = result.split(secret).join('[redacted]')
+    result = result
+      .replace(/\b(?:npm|gh[pousr]|github_pat|ov[a-z]{1,4})_[A-Za-z0-9_-]{16,}\b/g, '[redacted]')
+      .replace(/\bsk-(?:proj-|ant-)?[A-Za-z0-9_-]{16,}\b/g, '[redacted]')
+      .replace(/\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, '[redacted]')
+      .replace(/\bAIza[A-Za-z0-9_-]{35}\b/g, '[redacted]')
+      .replace(/\bxox[baprs]-[A-Za-z0-9-]{16,}\b/g, '[redacted]')
+      .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, '[redacted]')
+      .replace(/\bBearer\s+[^\s"'<>]+/gi, 'Bearer [redacted]')
+      .replace(/\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD))\s*=\s*(?:"[^"]*"|'[^']*'|[^\s;]+)/g, '$1=[redacted]')
+      .replace(/([?&](?:api[_-]?key|token|access_token|secret|password)=)[^&#\s]*/gi, '$1[redacted]')
+      .replace(/(https?:\/\/)[^/@\s]+:[^/@\s]+@/gi, '$1[redacted]@')
+    return result.slice(0, 4000)
+  }
+  const walk = (item, depth) => {
+    if (++visited > 2000 || depth > 8) return '[truncated]'
+    if (typeof item === 'string') return cleanString(item)
+    if (typeof item === 'number') return Number.isFinite(item) ? item : null
+    if (typeof item === 'bigint') return String(item)
+    if (item == null || typeof item === 'boolean') return item
+    if (typeof item !== 'object') return undefined
+    if (seen.has(item)) return '[circular]'
+    seen.add(item)
+    if (Array.isArray(item)) return item.slice(0, 80).map((child) => walk(child, depth + 1))
+    return Object.fromEntries(Object.entries(item).slice(0, 80).flatMap(([key, child]) => {
+      if (OMIT.test(key.replace(/[_-]/g, '')) || isPrivateThoughtEvent(key)) return []
+      const safe = walk(child, depth + 1)
+      return safe === undefined ? [] : [[cleanString(key).slice(0, 120), safe]]
+    }))
+  }
+  return walk(value, 0)
+}
+
+export function createAgentJournal({ stateDir, agent, secrets = [] }) {
+  const runId = randomUUID()
+  const identity = sanitizeJournalData({ identifier: String(agent?.identifier || agent?.slug || 'agent'), slug: String(agent?.slug || agent?.identifier || 'agent'), provider: String(agent?.provider || 'unknown') }, { secrets })
+  const slug = identity.slug.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 60) || 'agent'
+  const digest = createHash('sha256').update(identity.identifier + ':' + identity.provider).digest('hex').slice(0, 12)
+  const directory = join(stateDir, 'observability')
+  const stem = `${slug}-${digest}`
+  const path = join(directory, stem + '.jsonl')
+  let sequence = 0, pendingBytes = 0, dropped = 0, written = 0, lastError = null
+  let timer, heartbeat, closing = false, closePromise, writing = false
+  const pending = []
+  const ready = (async () => {
+    await mkdir(directory, { recursive: true, mode: 0o700 })
+    const entry = await lstat(directory)
+    if (!entry.isDirectory() || entry.isSymbolicLink()) throw new Error('Journal directory must be a real directory')
+    await chmod(directory, 0o700)
+  })()
+  // Initialization errors remain observable from close(), without an unhandled
+  // rejection or a synchronous failure in the watcher's critical path.
+  let writes = ready.catch((error) => { lastError = error })
+
+  const rotate = async () => {
+    const backup = (number) => join(directory, `${stem}.${number}.jsonl`)
+    await unlink(backup(2)).catch((error) => { if (error.code !== 'ENOENT') throw error })
+    await rename(backup(1), backup(2)).catch((error) => { if (error.code !== 'ENOENT') throw error })
+    await rename(path, backup(1)).catch((error) => { if (error.code !== 'ENOENT') throw error })
+  }
+  const flush = () => {
+    clearTimeout(timer); timer = null
+    if (writing || !pending.length) return writes
+    writing = true
+    const batch = pending.splice(0)
+    pendingBytes = 0
+    writes = writes.then(async () => {
+      await ready
+      const contents = batch.join('')
+      const size = await stat(path).then((entry) => entry.size).catch((error) => { if (error.code === 'ENOENT') return 0; throw error })
+      if (size + Buffer.byteLength(contents) > MAX_FILE_BYTES) await rotate()
+      const handle = await open(path, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | (constants.O_NOFOLLOW || 0), 0o600)
+      try { await handle.chmod(0o600); await handle.writeFile(contents); written += batch.length }
+      finally { await handle.close() }
+    }).catch((error) => { lastError = error }).finally(() => {
+      writing = false
+      if (pending.length && !closing && !timer) { timer = setTimeout(() => { void flush() }, 50); timer.unref?.() }
+    })
+    return writes
+  }
+  const enqueue = (type, data) => {
+    if (isPrivateThoughtEvent(type) || !/^[a-z][a-z0-9_.:-]{0,79}$/i.test(type)) return false
+    const safe = sanitizeJournalData(data, { secrets })
+    const event = { schemaVersion: 1, id: `${runId}:${++sequence}`, sequence, runId, timestamp: new Date().toISOString(), type, agent: identity, pid: process.pid, data: safe && typeof safe === 'object' ? safe : { value: safe } }
+    let line = JSON.stringify(event) + '\n'
+    if (Buffer.byteLength(line) > MAX_EVENT_BYTES) {
+      event.data = { truncated: true, summary: 'Event exceeded the local journal size limit', cycleId: safe?.cycleId }
+      line = JSON.stringify(event) + '\n'
+    }
+    const size = Buffer.byteLength(line)
+    while (pending.length && (pendingBytes + size > MAX_PENDING_BYTES || pending.length >= 256)) {
+      pendingBytes -= Buffer.byteLength(pending.shift()); dropped++
+    }
+    pending.push(line); pendingBytes += size
+    if (!timer) { timer = setTimeout(() => { void flush() }, 50); timer.unref?.() }
+    return true
+  }
+  const emit = (type, data = {}) => {
+    if (closing) return false
+    try { return enqueue(String(type || ''), data) }
+    catch (error) { lastError = error; return false }
+  }
+  emit('runtime.started', { status: 'running' })
+  heartbeat = setInterval(() => emit('runtime.heartbeat', { status: 'running', droppedEvents: dropped }), 15_000)
+  heartbeat.unref?.()
+  const close = () => {
+    if (closePromise) return closePromise
+    clearInterval(heartbeat)
+    emit('runtime.stopped', { status: 'stopped', droppedEvents: dropped })
+    closing = true
+    closePromise = (async () => {
+      while (pending.length || writing) await flush()
+      await writes
+      return { written, dropped, error: lastError ? sanitizeJournalData(String(lastError.message || lastError), { secrets }) : null }
+    })()
+    return closePromise
+  }
+  return { emit, close, runId }
+}

package/src/assignment-routing.mjs

@@ -1,7 +1,9 @@
+import { taskIsAwaitingReview, taskIsCompleted, ticketDisplaySlug } from './events.mjs'
+
 // Assignment requests are routed by the watcher, before the restricted chat
 // runtime can mistake its own tool limits for the coding worker's capabilities.
 export function assignmentStatusOnly(value) {
-  return /\b(?:do not|don't|dont|stop|cancel|stand down|status only|just (?:list|check|tell|show)|only (?:list|check|tell|show))\b/i.test(String(value || ''))
+  return /\b(?:(?:do\s+not|don't|dont)\s+(?:start|begin|resume|continue|implement|fix|finish|complete|handle|execute|dispatch|pick|work)|stop\s+(?:working|handling|on\s+this)|cancel\s+(?:this|that|it|the\s+(?:task|ticket))|stand\s+down|status\s+only|just\s+(?:list|check|tell|show)|only\s+(?:list|check|tell|show))\b/i.test(String(value || ''))
 }
 
 export function assignmentRequest(value) {
@@ -11,22 +13,32 @@ export function assignmentRequest(value) {
   const tickets = /\b(?:tickets?|tasks?|assignments?|backlog)\b/i.test(text) || slugs.length > 0
   const action = /\b(?:start|begin|resume|continue|implement|fix|finish|complete|handle|execute|dispatch|pick\s+up|work\s+(?:on|through))\b/i.test(text)
   const assigned = /\b(?:assigned|gave)\s+(?:\S+\s+){0,3}you\b|\byou\s+have\b.*\b(?:pending|assigned)\b/i.test(text)
+  if (!action && /\?|\b(?:check|list|show|tell|whether|how\s+many)\b/i.test(text)) return null
   return tickets && (action || assigned) ? { slugs } : null
 }
 
 export async function routeAssignments({ request, loadTickets, handleTask, isCancelled = () => false }) {
   const tickets = await loadTickets()
-  const selected = tickets.filter((ticket) => !request.slugs.length || request.slugs.includes(ticket.slug))
+  if (!Array.isArray(tickets)) throw new Error('The assignment list was not a valid ticket list.')
+  const selected = tickets.filter((ticket) => ticket && (!request.slugs.length || request.slugs.includes(ticketDisplaySlug(ticket))))
   // A project-scoped slug must resolve uniquely before any work is started.
   for (const slug of request.slugs) {
-    if (selected.filter((ticket) => ticket.slug === slug).length !== 1) {
+    if (selected.filter((ticket) => ticketDisplaySlug(ticket) === slug).length !== 1) {
       throw new Error(`I couldn't uniquely resolve ${slug} among my open assignments.`)
     }
   }
-  const actionable = selected.filter((ticket) => !ticket.awaitingReview)
+  const actionable = selected.filter((ticket) => !ticket.awaitingReview && !taskIsAwaitingReview(ticket) && !taskIsCompleted(ticket))
+  if (isCancelled()) return 0
+  if (actionable.some((ticket) => ticket.id == null || (ticket.projectId ?? ticket.project_id) == null)) {
+    throw new Error('An assignment is missing its ticket or project identity.')
+  }
+  const dispatched = new Set()
   for (const ticket of actionable) {
-    if (isCancelled()) return
-    await handleTask('task:assigned', { task: { id: ticket.id, project_id: ticket.projectId } })
+    if (isCancelled()) break
+    const key = `${ticket.projectId ?? ticket.project_id}:${ticket.id}`
+    if (dispatched.has(key)) continue
+    await handleTask('task:assigned', { task: { id: ticket.id, project_id: ticket.projectId ?? ticket.project_id } })
+    dispatched.add(key)
   }
-  return actionable.length
+  return dispatched.size
 }

package/src/authorization-resume.mjs

@@ -1,7 +1,7 @@
 // Authorization recovery takes precedence over the generic failed-revision
 // gate. Clearing only the policy block left tickets permanently stuck.
 export function releaseAuthorizedPause(key, { blocked, repos, failed, seen, authorized }) {
-  if (!blocked.has(key) || !repos.has(key) || !authorized(repos.get(key))) return false
+  if (!blocked.has(key) || !repos.has(key) || authorized(repos.get(key)) !== true) return false
   blocked.delete(key)
   repos.delete(key)
   failed.delete(key)