@ljwei-stak/dsh-model-route-bot 0.64.0 → 0.65.0

package/packages/orchestration/src/bot-routing-candidates.mjs

@@ -9,13 +9,13 @@
  * machine: `candidateMachineGrant` is the only way a caller may read one, and an unnamed machine
  * resolves to the Bot's own first grant rather than to a guess.
  *
- * Everything is injected — bots, their saved settings, machine health — so the same function runs
- * in the Host and in a test without a database or a live machine.
+ * Quality is a fraction between 0 and 1. Everything is injected — bots, their saved settings,
+ * machine health — so the same function runs in the Host and in a test without a database or a live machine.
  */
 
 import { workerBinding } from './bot-routing-mode.mjs'
 
-const finite = value => (typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null)
+const finite = (value, max = Infinity) => (typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= max ? value : null)
 const list = value => (Array.isArray(value) ? value : [])
 
 /** Tools a Bot may actually use, from its compiled grant rather than from its own claims. */
@@ -96,7 +96,7 @@ export function candidateMachineGrant(candidate, machineId = '', rootId = '') {
  *   settingsFor: (botId: string) => { enabled?: boolean, model?: object, grant?: { tools?: string[] }, capabilities?: string[], machineGrants?: Array<object> } | null,
  *   machineHealth?: (machineId: string) => { online?: boolean } | null,
  *   qualityFor?: (botId: string) => number | null,
- *   priceFor?: (route: { provider: string, model: string }) => number | null,
+ *   priceFor?: (route: { provider: string, model: string }, botId: string) => number | null,
  *   loadFor?: (botId: string) => number | null,
  *   busyFor?: (botId: string) => boolean,
  * }} source
@@ -110,7 +110,7 @@ export function botRoutingCandidates({ bots = [], settingsFor, machineHealth = (
     // A Bot that is off is not a candidate; it stays out rather than scoring last.
     if (!settings || settings.enabled === false || settings.status && settings.status !== 'available') continue
     const model = settings.model ?? bot.model ?? null
-    const price = model ? priceFor(model) : null
+    const price = model ? priceFor(model, bot.id) : null
     // Machine grants name the machine and the tools that machine offers this Bot. Reachability is
     // asked per machine, so a Bot with two grants reports the one the task is about.
     const machineGrants = machineGrantsOf(settings)
@@ -125,7 +125,7 @@ export function botRoutingCandidates({ bots = [], settingsFor, machineHealth = (
       // Unknown price and unknown quality stay null: the router treats them as unknown, not as
       // zero or best, and never as "free".
       pricePerMTokUsd: finite(price),
-      quality: finite(qualityFor(bot.id)),
+      quality: finite(qualityFor(bot.id), 1),
       load: finite(loadFor(bot.id)) ?? 0,
       busy: busyFor(bot.id) === true,
       tools: toolsOf(settings),

package/packages/orchestration/src/bot-routing-service.mjs

@@ -17,16 +17,18 @@
 import { botRoutingCandidates, candidateMachineGrant, withMachineFact } from './bot-routing-candidates.mjs'
 import { routeBot } from './bot-routing.mjs'
 import { normalizeBotRouting, workerBinding } from './bot-routing-mode.mjs'
-import { dispatchRoutedTask, pinnedMachineRefusal, workerGrantFact, routedEffectClass } from './bot-routing-dispatch.mjs'
+import { assertPlanAccepted, dispatchRoutedTask, pinnedMachineRefusal, workerGrantFact, routedEffectClass } from './bot-routing-dispatch.mjs'
+import { canonicalTaskJson, taskRef } from './task-contract.mjs'
 import { createHash } from 'node:crypto'
 const fail = code => { const error = new Error(code); error.code = code; throw error }
+const submittedPlanId = (originBotId, requestKey) => `route_${createHash('sha256').update(`${originBotId}:${requestKey}`).digest('hex').slice(0, 48)}`
 
 /**
  * @param {{
  *   bots: () => Array<object>,
  *   settingsFor: (botId: string) => object | null,
  *   machineHealth?: (machineId: string) => { online?: boolean } | null,
- *   priceFor?: (route: object) => number | null,
+ *   priceFor?: (route: object, botId: string) => number | null,
  *   qualityFor?: (botId: string) => number | null,
  *   loadFor?: (botId: string) => number | null,
  *   busyFor?: (botId: string) => boolean,
@@ -36,9 +38,10 @@ const fail = code => { const error = new Error(code); error.code = code; throw e
  *   subjectFor?: (botId: string) => unknown,
  *   bindWorker?: (binding: object) => Promise<unknown> | unknown,
  *   newTaskId?: () => string,
+ *   readSubmittedPlan?: (originBotId: string, planId: string) => object | Promise<object>,
  * }} source
  */
-export function createBotRoutingService({ bots, settingsFor, machineHealth, priceFor, qualityFor, loadFor, busyFor, routing, mainBotIds = [], submitPlan = null, subjectFor = null, bindWorker = null, newTaskId = null, executionBackendFor = null, settle = null, deliver = null, onAccepted = null }) {
+export function createBotRoutingService({ bots, settingsFor, machineHealth, priceFor, qualityFor, loadFor, busyFor, routing, mainBotIds = [], submitPlan = null, subjectFor = null, bindWorker = null, newTaskId = null, readSubmittedPlan = null, executionBackendFor = null, settle = null, deliver = null, onAccepted = null }) {
   if (typeof bots !== 'function') fail('BOT_ROUTING_REQUIRES_BOTS')
   if (typeof settingsFor !== 'function') fail('BOT_ROUTING_REQUIRES_SETTINGS')
 
@@ -81,7 +84,7 @@ export function createBotRoutingService({ bots, settingsFor, machineHealth, pric
         quality: candidate.quality,
         busy: candidate.busy,
       }))
-      return { enabled: settings.enabled, preset: settings.preset, autoGrant: settings.autoGrant, candidates: rows }
+      return { enabled: settings.enabled, preset: settings.preset, autoGrant: settings.autoGrant, requesterBotId: readMainBotIds()[0] ?? null, candidates: rows }
     },
 
     /**
@@ -132,6 +135,27 @@ export function createBotRoutingService({ bots, settingsFor, machineHealth, pric
       }
     },
 
+    /** Owner-only observation: no candidate reads, grant changes, runner or routing switch needed. */
+    async submissionStatus(payload, context = {}) {
+      if (context?.kind !== 'owner') fail('REMOTE_OWNER_REQUIRED')
+      const value = JSON.parse(canonicalTaskJson(payload))
+      if (!value || Array.isArray(value) || Object.keys(value).some(key => !['requestKey', 'requesterBotId'].includes(key))) fail('INVALID_TASK_REQUEST')
+      const requestKey = taskRef(value.requestKey), originBotId = taskRef(value.requesterBotId)
+      if (typeof readSubmittedPlan !== 'function') fail('BOT_ROUTING_STATUS_UNAVAILABLE')
+      const planId = submittedPlanId(originBotId, requestKey)
+      let plan
+      try { plan = await readSubmittedPlan(originBotId, planId) }
+      catch (error) {
+        if (error?.code !== 'TASK_PLAN_NOT_FOUND') throw error
+        // This is a point-in-time read. An original request may still commit later.
+        return { found: false, planId, originBotId, planState: null, packages: [] }
+      }
+      if (plan?.planId !== planId || plan?.ownerBotId !== originBotId) fail('BOT_ROUTING_SUBMISSION_IDENTITY_MISMATCH')
+      const accepted = assertPlanAccepted(plan)
+      return { found: true, accepted: true, planId, originBotId, planState: accepted.state,
+        packages: accepted.packages.map(({ id, targetBotId, taskId, attemptId, operationId, state }) => ({ id, targetBotId, taskId, attemptId, operationId, state })) }
+    },
+
     /**
      * Dispatch for real. The Host injects plan submission and the subject directory; without them
      * this refuses, because a dispatch that cannot create a task must not look like one.
@@ -153,6 +177,7 @@ export function createBotRoutingService({ bots, settingsFor, machineHealth, pric
       if (!subjectFor(originBotId)) fail('ROUTING_SUBJECT_UNKNOWN')
       if (!owner && !readMainBotIds().includes(requesterBotId)) fail(`BOT_ROUTING_DISPATCH_DENIED:${requesterBotId}`)
       if (!owner && (typeof context.sessionId !== 'string' || context.sessionId === '')) fail('BOT_ROUTING_SESSION_REQUIRED')
+      if (payload.requestKey !== undefined && payload.requestKey !== '') taskRef(payload.requestKey)
       const needs = routingNeeds(payload)
       const decision = service.decide({ ...payload, needs, requesterBotId })
       if (!decision.chosen) fail(`BOT_ROUTING_NO_ELIGIBLE:${decision.rejected.map(row => row.reason).join(',') || 'none'}`)
@@ -184,7 +209,7 @@ export function createBotRoutingService({ bots, settingsFor, machineHealth, pric
         settle: typeof settle === 'function' ? report => settle(report, context) : null,
         deliver: typeof deliver === 'function' ? report => deliver(report, context) : null,
         newTaskId: typeof payload.requestKey === 'string' && payload.requestKey !== ''
-          ? () => `route_${createHash('sha256').update(`${originBotId}:${payload.requestKey}`).digest('hex').slice(0, 48)}`
+          ? () => submittedPlanId(originBotId, payload.requestKey)
           : typeof newTaskId === 'function' ? newTaskId : undefined,
       })
       if (typeof onAccepted === 'function') await onAccepted(report, context)

package/packages/orchestration/src/bot-routing.mjs

@@ -16,7 +16,7 @@
 export const BOT_ROUTING_PRESETS = Object.freeze(['economy', 'balanced', 'quality'])
 
 const fail = code => { const error = new Error(code); error.code = code; throw error }
-const finite = value => (typeof value === 'number' && Number.isFinite(value) ? value : null)
+const finite = (value, max = Infinity) => (typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= max ? value : null)
 const list = value => (Array.isArray(value) ? value : [])
 
 /** Hard requirements a Bot must satisfy before it is even scored. */
@@ -53,7 +53,7 @@ export const botRejection = (candidate, task = {}) => rejection(candidate, task)
 /** Lower is better. Unknown cost sorts after known cost but is never silently free. */
 function score(candidate, preset, maxPrice) {
   const price = finite(candidate.pricePerMTokUsd)
-  const quality = finite(candidate.quality)
+  const quality = finite(candidate.quality, 1)
   const load = finite(candidate.load) ?? 0
   // Cost is normalised against the most expensive eligible Bot, so one very expensive route
   // cannot swamp quality evidence: what matters is the ratio within this decision, not dollars.
@@ -91,9 +91,11 @@ export function routeBot({ task = {}, candidates = [], preset = 'balanced', limi
   const scored = []
   for (const candidate of eligible) {
     scored.push({ botId: candidate.botId, score: score(candidate, preset, maxPrice), model: candidate.model,
-      pricePerMTokUsd: finite(candidate.pricePerMTokUsd), quality: finite(candidate.quality) })
+      pricePerMTokUsd: finite(candidate.pricePerMTokUsd), quality: finite(candidate.quality, 1) })
   }
-  scored.sort((left, right) => left.score - right.score || String(left.botId).localeCompare(String(right.botId)))
+  scored.sort((left, right) => left.score - right.score
+    || Number(left.pricePerMTokUsd === null) - Number(right.pricePerMTokUsd === null)
+    || String(left.botId).localeCompare(String(right.botId)))
   const ranked = scored.slice(0, Math.max(1, limit))
   return {
     preset,

package/packages/orchestration/src/product-composition.mjs

@@ -27,6 +27,7 @@ import { openBotSettings } from './bot-settings.mjs'
 import { openFundingAccounts } from './funding-accounts.mjs'
 import { createModelAccounting } from './model-accounting.mjs'
 import { createTaskService } from './task-service.mjs'
+import { inspectProductTask, projectProductTask } from './task-product.mjs'
 import { createDesktopActions } from './desktop-actions.mjs'
 import { registerTaskTools } from './task-tools.mjs'
 import { createMrReadBackend } from './mr-read-backend.mjs'
@@ -343,19 +344,22 @@ export function startBotProduct(ctx, options = {}) {
       if (!taskService) throw new Error('TASK_SERVICE_UNAVAILABLE')
       return taskService.submitPlan(subject, request, caller)
     },
+    readSubmittedPlan: (originBotId, planId) => {
+      if (!journal) throw Object.assign(new Error('BOT_ROUTING_STATUS_UNAVAILABLE'), { code: 'BOT_ROUTING_STATUS_UNAVAILABLE' })
+      // Authenticated owner observation reads durable identities even if the Bot was paused.
+      return journal.getPlan(originBotId, planId)
+    },
     bindWorker: (binding, context) => commitWorkerBinding(binding, context),
     executionBackendFor: effect => effect === 'read' ? 'bot-turn-read' : 'bot-turn-write',
     onAccepted: report => turnBackends?.watchPlan(report),
     busyFor: botId => product?.rt.live?.get(product.rt.chatOf(botId))?.turn !== undefined,
-    priceFor: route => {
-      for (const bot of product?.lifecycle.committedBots() ?? []) {
-        const settings = routingSettingsFor(bot.id)
-        if (settings?.model?.provider === route.provider && settings.model.model === route.model) {
-          const price = settings.funding?.pricing
-          if (typeof price?.input === 'number' && typeof price.output === 'number') return (price.input + price.output) / 2
-        }
-      }
-      return null
+    priceFor: (route, botId) => {
+      // Funding prices belong to the Bot binding, even when another Bot uses the same model.
+      const settings = routingSettingsFor(botId)
+      if (settings?.model?.provider !== route.provider || settings.model.model !== route.model) return null
+      const price = settings.funding?.pricing
+      if (!Number.isFinite(price?.input) || price.input < 0 || !Number.isFinite(price?.output) || price.output < 0) return null
+      return (price.input + price.output) / 2
     },
   })
   ctx.provide('botRouting', botRouting)
@@ -729,22 +733,10 @@ export function startBotProduct(ctx, options = {}) {
           // same single authority; a section without a runner stays blocked.
           ...(taskService ? { tasks: async ({ runtime, signal }) => {
             signal?.throwIfAborted(); await runtime.load()
-            const items = []
-            for (const bot of Object.values(runtime.state?.bots ?? {})) {
-              for (const task of journal.list(bot.id)) {
-                if (items.length >= TASK_READ_LIMIT) break
-                items.push({ botId: task.ownerBotId, taskId: task.taskId, state: task.state, backend: task.input.backend,
-                  ...(task.planId?{planId:task.planId,logicalPackageId:task.logicalPackageId}:{}),
-                  location: task.input.target.location, machineId: task.input.target.machineId, workspaceId: task.input.target.workspaceId,
-                  createdAt: task.createdAt, updatedAt: task.updatedAt, deadlineAt: task.deadlineAt,
-                  attemptNumber: task.attemptNumber, operationId: task.operationId, attempts: task.attempts.length,
-                  legacyRunIds: task.legacyRunIds, result: task.result ? { code: task.result.code ?? task.result.summary?.code ?? null,
-                    ...(task.executionRef?.kind==='remote-operation'?{remote:{status:['succeeded','failed','cancelled','admitted','running','cancel_pending','unknown'].includes(task.result.summary?.status)?task.result.summary.status:'unknown',stopConfirmed:task.result.summary?.stopConfirmed===true,possiblyApplied:task.result.summary?.possiblyApplied!==false,...(/^[a-f0-9]{64}$/.test(task.result.summary?.sha256??'')?{sha256:task.result.summary.sha256}:{}),...(Number.isSafeInteger(task.result.summary?.bytes)?{bytes:task.result.summary.bytes}:{}),...(Number.isSafeInteger(task.result.summary?.exitCode)?{exitCode:task.result.summary.exitCode}:{}),...(task.result.summary?.notStarted===true?{notStarted:true}:{})}}:{}) } : null,
-                  reconciliation: task.reconciliation ? { at: task.reconciliation.at, outcome: task.reconciliation.outcome } : null })
-              }
-            }
+            const loaded = journal.productList(Object.values(runtime.state?.bots ?? {}).map(bot => bot.id), { limit: TASK_READ_LIMIT })
+            const items = loaded.items.map(projectProductTask)
             const plans=Object.values(runtime.state?.bots??{}).flatMap(bot=>journal.listPlans(bot.id))
-            return { status: 'available', items, plans, backends: taskBackends.catalog() }
+            return { status: 'available', items, total: loaded.total, truncated: loaded.truncated, plans, backends: taskBackends.catalog() }
           } } : {}),
           // N07: the usage projection reads the durable source receipts and the
           // funding totals from the single authority; an unknown amount stays
@@ -837,6 +829,7 @@ export function startBotProduct(ctx, options = {}) {
           // action. Registering it here is what makes the routing card work at runtime; the owner
           // RPC methods are a second door onto the same service.
           'botRoutingInspect': async () => ({ ...botRouting.inspect(), settingsRevision: routingSettings.get().revision }),
+          'botRouting.status': (payload, context) => botRouting.submissionStatus(payload, context),
           'botRouting.save': async (payload, context) => {
             const saved = routingSettings.save(payload, context)
             return { ...botRouting.inspect(), settingsRevision: saved.revision }
@@ -873,6 +866,7 @@ export function startBotProduct(ctx, options = {}) {
           // N09: owner task management runs on the owning Bot's own subject, so
           // the Bot's committed grant authorizes every cancel/retry/reconcile.
           ...(taskService ? {
+            'task.inspect': payload => inspectProductTask({ service: taskService, journal, subject: taskOwner(payload), taskId: payload?.taskId }),
             // Bot routing turns a preview into a real package: the decision names the Bot, the
             // worker binding is committed first, and only then is the plan submitted. A failure in
             // either step leaves no half-dispatched task behind.

package/packages/orchestration/src/task-journal.mjs

@@ -541,6 +541,29 @@ export function openTaskJournal(Database, path, {database=null,financialEpoch=nu
       })
     },
     events(owner,id) {owned(owner,id);return stmt('SELECT * FROM task_events WHERE task_id=? ORDER BY seq').all(id)},
+    timeline(owner,id,{limit=80}={}) {
+      owned(owner,id)
+      if(!Number.isSafeInteger(limit)||limit<1||limit>200)fail('INVALID_TASK_HISTORY_LIMIT')
+      const total=stmt('SELECT COUNT(*) AS n FROM task_events WHERE task_id=?').get(id).n
+      const items=stmt('SELECT * FROM task_events WHERE task_id=? ORDER BY seq DESC LIMIT ?').all(id,limit).reverse()
+      return {items,total,truncated:total>items.length}
+    },
+    // Product lists must not permanently hide new tasks behind a Bot's first 128 records.
+    // This read is global across the Host's known Bots; it never changes runner queue ordering.
+    productList(owners,{limit=512}={}) {
+      if(!Array.isArray(owners)||!Number.isSafeInteger(limit)||limit<1||limit>512)fail('INVALID_TASK_LIST')
+      const ids=[...new Set(owners.map(taskRef))]
+      if(!ids.length)return {items:[],total:0,truncated:false}
+      const visible=new Set(ids)
+      const total=stmt('SELECT owner_bot,COUNT(*) AS n FROM tasks GROUP BY owner_bot').all()
+        .reduce((sum,row)=>sum+(visible.has(row.owner_bot)?row.n:0),0)
+      // Filter owners before the limit, including when old/deleted Bots still have records.
+      const items=stmt(`SELECT id,owner_bot FROM tasks WHERE owner_bot IN (SELECT value FROM json_each(?))
+        ORDER BY CASE WHEN state IN ('needs-reconciliation','waiting-approval','waiting-budget','blocked') THEN 0
+          WHEN state IN ('ready','queued','running','cancelling','admitting') THEN 1 WHEN state='failed' THEN 2 ELSE 3 END,
+          updated_ms DESC,id LIMIT ?`).all(JSON.stringify(ids),limit).map(row=>view(row.owner_bot,row.id))
+      return {items,total,truncated:total>items.length}
+    },
     // One Bot's durable tasks, oldest first; the read model never invents a task.
     list(owner) {taskRef(owner);return stmt('SELECT id FROM tasks WHERE owner_bot=? ORDER BY created_ms,id LIMIT 128').all(owner).map(row=>view(owner,row.id))},
     close() {if(!closed){closed=true;if(!borrowed)db.close();onClose()}},

package/packages/orchestration/src/task-product.mjs

@@ -0,0 +1,49 @@
+// Public task views contain execution identities and status evidence, never backend inputs,
+// execution references, raw event details or reconciliation proofs.
+const short = (value, limit = 160) => typeof value === 'string' ? value.replace(/\s+/g, ' ').trim().slice(0, limit) : ''
+const code = value => typeof value === 'string' && /^[A-Z0-9_:-]{1,128}$/.test(value) ? value : null
+
+export function projectProductTask(task) {
+  const input = task.input?.input ?? {}
+  const title = short(input.task || input.text || input.prompt) || (input.relativePath ? short(`文件操作：${input.relativePath}`) : '')
+  const remote = task.result?.summary
+  return {
+    botId: task.ownerBotId, taskId: task.taskId, packageId: task.packageId, attemptId: task.attemptId,
+    state: task.state, title, backend: task.input?.backend,
+    ...(task.planId ? { planId: task.planId, logicalPackageId: task.logicalPackageId } : {}),
+    location: task.input?.target?.location, machineId: task.input?.target?.machineId, workspaceId: task.input?.target?.workspaceId,
+    createdAt: task.createdAt, updatedAt: task.updatedAt, deadlineAt: task.deadlineAt,
+    attemptNumber: task.attemptNumber, operationId: task.operationId, attempts: task.attempts.length,
+    legacyRunIds: task.legacyRunIds,
+    result: task.result ? { code: code(task.result.code ?? remote?.code),
+      ...(task.executionRef?.kind === 'remote-operation' ? { remote: {
+        status: ['succeeded', 'failed', 'cancelled', 'admitted', 'running', 'cancel_pending', 'unknown'].includes(remote?.status) ? remote.status : 'unknown',
+        stopConfirmed: remote?.stopConfirmed === true, possiblyApplied: remote?.possiblyApplied !== false,
+        ...(/^[a-f0-9]{64}$/.test(remote?.sha256 ?? '') ? { sha256: remote.sha256 } : {}),
+        ...(Number.isSafeInteger(remote?.bytes) ? { bytes: remote.bytes } : {}),
+        ...(Number.isSafeInteger(remote?.exitCode) ? { exitCode: remote.exitCode } : {}),
+        ...(remote?.notStarted === true ? { notStarted: true } : {}),
+      } } : {}),
+    } : null,
+    reconciliation: task.reconciliation ? { at: task.reconciliation.at, outcome: task.reconciliation.outcome } : null,
+  }
+}
+
+/** The service checks the Bot's committed task/read grant and the task's owner first. */
+export function inspectProductTask({ service, journal, subject, taskId }) {
+  const task = service.get(subject, { taskId })
+  const history = journal.timeline(task.ownerBotId, task.taskId)
+  const attempts = task.attempts.map(row => ({ attemptId: row.id, number: row.number, state: row.state,
+    operationId: row.operation_id, startedAt: row.started_ms, finishedAt: row.finished_ms }))
+  const byId = new Map(attempts.map(row => [row.attemptId, row]))
+  return { task: projectProductTask(task), attempts, timeline: {
+    total: history.total, truncated: history.truncated,
+    items: history.items.map(row => {
+      const detail = JSON.parse(row.detail), attempt = byId.get(row.attempt_id)
+      return { seq: row.seq, kind: row.kind, at: row.at_ms, attemptId: row.attempt_id,
+        attemptNumber: attempt?.number ?? null, operationId: attempt?.operationId ?? null,
+        outcome: ['ready', 'running', 'succeeded', 'failed', 'cancelled', 'blocked', 'skipped', 'waiting-budget', 'needs-reconciliation', 'unknown'].includes(detail.outcome) ? detail.outcome : null,
+        code: code(detail.code) }
+    }),
+  } }
+}

package/remote-computer-agent/build.mjs

@@ -1,16 +1,51 @@
 import { build } from 'esbuild'
-import { copyFile, mkdir, lstat, rm } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import { mkdir, lstat, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
-import { resolve, relative } from 'node:path'
+import { basename, dirname, join, resolve, relative } from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
 import assert from 'node:assert/strict'
-const root=fileURLToPath(new URL('.', import.meta.url))
-const output=resolve(root,'dist')
-assert.equal(relative(resolve(root),output),'dist','Build output must remain in the Agent dist directory')
-const previous=await lstat(output).catch(error=>{if(error.code==='ENOENT')return null;throw error})
-assert.ok(!previous?.isSymbolicLink(),'Refusing to replace a linked build output')
-await rm(output,{recursive:true,force:true})
-const options={absWorkingDir:root,bundle:true,packages:'external',platform:'node',format:'esm',target:'node22',sourcemap:true}
-await build({...options,entryPoints:['src/index.ts','src/cli.ts'],outbase:'src',outdir:'dist',outExtension:{'.js':'.mjs'}})
-await mkdir(`${root}dist`,{recursive:true})
-await build({...options,entryPoints:['../packages/capability-broker/src/cli-stdio-bridge.mjs'],outfile:'dist/cli-stdio-bridge.mjs'})
-for(const helper of ['native-peer.ps1','native-peer.py'])await copyFile(`${root}../packages/cli-runtime/src/${helper}`,`${root}dist/${helper}`)
+
+const root = fileURLToPath(new URL('.', import.meta.url))
+const output = resolve(root, 'dist')
+assert.equal(relative(resolve(root), output), 'dist', 'Build output must remain in the Agent dist directory')
+async function checkOutput() {
+  const previous = await lstat(output).catch(error => { if (error.code === 'ENOENT') return null; throw error })
+  assert.ok(!previous?.isSymbolicLink(), 'Refusing to replace a linked build output')
+  assert.ok(!previous || previous.isDirectory(), 'Agent build output must be a directory')
+}
+await checkOutput()
+
+// Compile everything before touching the published build. Native tests run separate builders
+// while other processes import or launch these entry points; deleting dist creates an ENOENT race.
+const options = { absWorkingDir: root, bundle: true, packages: 'external', platform: 'node', format: 'esm', target: 'node22', sourcemap: true, write: false }
+const main = await build({ ...options, entryPoints: ['src/index.ts', 'src/cli.ts'], outbase: 'src', outdir: 'dist', outExtension: { '.js': '.mjs' } })
+const bridge = await build({ ...options, entryPoints: ['../packages/capability-broker/src/cli-stdio-bridge.mjs'], outfile: 'dist/cli-stdio-bridge.mjs' })
+const files = [...main.outputFiles, ...bridge.outputFiles]
+for (const helper of ['native-peer.ps1', 'native-peer.py']) {
+  files.push({ path: join(output, helper), contents: await readFile(resolve(root, '../packages/cli-runtime/src', helper)) })
+}
+for (const file of files) assert.equal(dirname(resolve(file.path)), output, 'Agent build files must remain directly inside dist')
+await checkOutput()
+await mkdir(output, { recursive: true })
+const previousFiles = await readdir(output, { withFileTypes: true })
+assert.ok(previousFiles.every(file => !file.isDirectory()), 'Unexpected directory in flat Agent build output')
+for (const file of files) {
+  const bytes = Buffer.from(file.contents)
+  const previous = await readFile(file.path).catch(error => { if (error.code === 'ENOENT') return null; throw error })
+  if (previous?.equals(bytes)) continue
+  // Temporary files stay outside dist so another builder cannot prune or package them.
+  const temporary = join(root, `.agent-build-${randomUUID()}.tmp`)
+  try {
+    await writeFile(temporary, bytes, { flag: 'wx', mode: bytes.subarray(0, 2).toString() === '#!' ? 0o755 : 0o644 })
+    for (let attempt = 0; ; attempt++) {
+      try { await rename(temporary, file.path); break }
+      catch (error) {
+        if (attempt >= 5 || !['EPERM', 'EACCES', 'EBUSY'].includes(error.code)) throw error
+        await sleep(50)
+      }
+    }
+  } finally { await rm(temporary, { force: true }) }
+}
+const names = new Set(files.map(file => basename(file.path)))
+for (const file of previousFiles) if (!names.has(file.name)) await rm(join(output, file.name), { force: true })