fix(taskyon): stabilize cross-runtime diagnostics

  Rename worker cancellation and await complete teardown before releasing resources.
  Label timed-out FRP requests and support long storage identifiers safely.
  Align shared API diagnostics across browser and CLI runtimes.
  Add category-aware diagnostic commands and an aggregate test workflow.

Author: yeus

package.json

@@ -68,13 +68,21 @@
     "tauri:build": "tauri build",
     "tycli:build": "yarn workspace @taskyon/tycli build",
     "tycli:diagnostics": "yarn workspace @taskyon/tycli cli-diagnostics",
+    "tycli:diagnostics:authenticated": "yarn tycli:diagnostics --online --category authenticated",
+    "tycli:diagnostics:experimental": "yarn tycli:diagnostics --experimental --online --category experimental",
+    "tycli:diagnostics:large-tokens": "yarn tycli:diagnostics --large-tokens --online --category large-tokens",
     "tycli:diagnostics:list": "yarn workspace @taskyon/tycli cli-diagnostics:list",
+    "tycli:diagnostics:long-running": "yarn tycli:diagnostics --experimental --online --allow-long-run --category long-running",
+    "tycli:diagnostics:model-based": "yarn tycli:diagnostics --large-tokens --online --category model-based",
     "tycli:diagnostics:modelica": "yarn workspace @taskyon/tycli cli-diagnostics:modelica",
+    "tycli:diagnostics:network": "yarn tycli:diagnostics --online --category network",
+    "tycli:diagnostics:standard": "yarn tycli:diagnostics --category standard",
     "tycli:discovery-fixture": "yarn workspace @taskyon/tycli discovery-fixture",
     "tycli:lint": "yarn workspace @taskyon/tycli lint",
     "tycli:typecheck": "yarn workspace @taskyon/tycli typecheck",
     "tycli:prod": "yarn tycli:build && node packages/tycli/dist/cli.cjs",
     "tycli": "yarn workspace @taskyon/tycli dev",
+    "test:all": "yarn lint && yarn tycli:diagnostics --online && yarn test:e2e",
     "test:e2e": "playwright test",
     "test:e2e:online": "PLAYWRIGHT_REQUIRE_ONLINE=1 playwright test",
     "test:e2e:headed": "playwright test --headed",

packages/common/modules/diagnosticsRunner.ts

@@ -18,6 +18,7 @@ export interface TaskyonTestFn {
   gui?: boolean
   experimental?: boolean
   requiresLargeTokens?: boolean
+  requiresLongRun?: boolean
   requiresAuth?: boolean
   modelBased?: boolean
   helper?: boolean

packages/common/modules/frpBus.ts

@@ -1316,6 +1316,7 @@ export function createStreamRpcRequest<
   return awaitRequestResponse({
     subscribe: options.port.receive,
     sendRequest: () => options.port.send(options.request),
+    requestLabel: options.requestId,
     timeoutMs: options.timeoutMs,
     signal: options.signal,
     sendCancel: createCancelRequest

packages/common/modules/requestLifecycle.ts

@@ -22,6 +22,7 @@ export function awaitRequestResponse<TReceive, TResult>(options: {
   subscribe(receive: (message: TReceive) => void): RequestUnsubscribe
   sendRequest(): void
   sendCancel?: ((reason: string) => void) | undefined
+  requestLabel?: string | undefined
   timeoutMs?: number | undefined
   signal?: AbortSignal | undefined
   readResponse(message: TReceive): RequestResult<TResult> | undefined
@@ -83,13 +84,12 @@ export function awaitRequestResponse<TReceive, TResult>(options: {
       })
       options.signal?.addEventListener('abort', abort, { once: true })
       if (options.timeoutMs !== undefined) {
-        timeout = setTimeout(
-          () =>
-            cancel(
-              interruptionError('TimeoutError', `Request timed out after ${options.timeoutMs}ms`),
-            ),
-          options.timeoutMs,
+        const requestContext = options.requestLabel ? ` (${options.requestLabel})` : ''
+        const timeoutError = interruptionError(
+          'TimeoutError',
+          `Request timed out after ${options.timeoutMs}ms${requestContext}`,
         )
+        timeout = setTimeout(() => cancel(timeoutError), options.timeoutMs)
       }
       options.sendRequest()
     } catch (error) {

packages/common/modules/test_requestLifecycle.ts

@@ -85,11 +85,13 @@ export const testRequestLifecycleTimesOutAndCleansUp = async () => {
     awaitRequestResponse({
       subscribe: harness.subscribe,
       sendRequest: () => undefined,
+      requestLabel: 'example.request-1',
       timeoutMs: 1,
       readResponse: () => undefined,
     }),
   )
   assert(error.name === 'TimeoutError', 'Expected an explicit timeout error.')
+  assert(error.message.includes('example.request-1'), 'Expected the request label in the error.')
   assert(harness.unsubscribeCount() === 1, 'Expected cleanup after a timeout.')
   return { success: true }
 }

packages/runtime-browser/src/core.ts

@@ -79,13 +79,16 @@ export const createTaskyonBrowserCoreRuntime = (options: TaskyonBrowserCoreRunti
     stop?.()
   }
 
-  const disposeCore = (core: Awaited<ReturnType<typeof tyCore>>, reason: string) => {
+  const disposeCore = async (core: Awaited<ReturnType<typeof tyCore>>, reason: string) => {
     if (disposed) return
     disposed = true
     disconnectCore?.()
     disconnectCore = undefined
-    core.dispose(reason)
-    stopStorageService()
+    try {
+      await core.dispose(reason)
+    } finally {
+      stopStorageService()
+    }
   }
 
   const taskyon = (async () => {
@@ -122,7 +125,7 @@ export const createTaskyonBrowserCoreRuntime = (options: TaskyonBrowserCoreRunti
       disconnectCore = corePort.connect(core.port)
       corePort.send({ type: 'taskyonReady' })
       options.onStage?.('ready')
-      if (stopReason) disposeCore(core, stopReason)
+      if (stopReason) await disposeCore(core, stopReason)
       return core
     } catch (error) {
       stopStorageService()
@@ -139,7 +142,7 @@ export const createTaskyonBrowserCoreRuntime = (options: TaskyonBrowserCoreRunti
       if (stopReason) return
       stopReason = reason
       const core = await taskyon
-      disposeCore(core, reason)
+      await disposeCore(core, reason)
     },
   }
 }

packages/taskyon/src/api/storageRecordFileBackend.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod'
+import { canonicalHash } from '@taskyon/common/modules/canonicalHash'
 import { deepMerge } from '../utils/objHelpers'
 import type { StorageRecordBackend } from './storageProtocol'
 
@@ -71,11 +72,19 @@ const mergeStorageRecord = (
 export const storageRecordNamespacePath = (namespace: string) =>
   ['records', ...namespace.split('/').map(encodeURIComponent)].join('/')
 
+const MAX_READABLE_ID_LENGTH = 160
+
+const storageRecordFileName = (id: string | number) => {
+  const type = typeof id
+  const encodedId = encodeURIComponent(String(id))
+  if (encodedId.length <= MAX_READABLE_ID_LENGTH) return `${type}-${encodedId}.json`
+
+  const digest = canonicalHash({ type, value: id }).slice('sha256:'.length)
+  return `${type}-sha256-${digest}.json`
+}
+
 export const storageRecordFilePath = (namespace: string, id: string | number) =>
-  [
-    storageRecordNamespacePath(namespace),
-    `${typeof id}-${encodeURIComponent(String(id))}.json`,
-  ].join('/')
+  [storageRecordNamespacePath(namespace), storageRecordFileName(id)].join('/')
 
 export const createStorageRecordFileBackend = (
   adapter: StorageRecordFileAdapter,

packages/taskyon/src/core/init.ts

@@ -431,7 +431,7 @@ const dynamicContext =
     }
     const continuationTask = partialTaskDraft.parse(entryNode())
     const taskWorkerConfig = llmSettings().taskWorker
-    const { workerStream, toolRpcPort, workerStop, queueTask } = runTaskWorker(
+    const { workerStream, toolRpcPort, cancelCurrentRun, workerSettled, queueTask } = runTaskWorker(
       taskManagerInstance,
       continuationTask,
       continuationTask,
@@ -487,23 +487,24 @@ const dynamicContext =
     return {
       callTool: (name: string, args: FunctionArguments) => toolExecutionClient.callTool(name, args),
       runtimeConfiguration,
-      workerStop: (message: string) => {
+      cancelCurrentRun: (message: string) => {
         console.log('tycore stopping all tasks:', message)
-        workerStop(message)
+        cancelCurrentRun(message)
         workerToolBroker.stop(message)
         coreToolExecutor.stop(message)
       },
-      dispose: (message: string) => {
+      dispose: async (message: string) => {
         if (disposed) return
         disposed = true
         console.log('tycore disposing session context:', message)
         unsubscribeChatCompletion()
         unsubscribeSessionStreams.forEach((unsubscribe) => unsubscribe())
-        workerStop(message)
-        workerToolBroker.stop(message)
-        coreToolExecutor.stop(message)
         unsubscribeApiServer()
         unsubscribeHostApiServer()
+        cancelCurrentRun(message)
+        workerToolBroker.stop(message)
+        coreToolExecutor.stop(message)
+        await workerSettled()
         unsubscribeTaskStreamBridge()
         workerToolBroker.destroy()
         coreToolExecutor.destroy()
@@ -586,7 +587,7 @@ export async function tyCore(
 
   const replaceSessionContext = async (newCs: CryptoSession) => {
     const currentToolchainConfig = ctx.runtimeConfiguration.toolchainConfig
-    ctx.dispose('switching crypto session')
+    await ctx.dispose('switching crypto session')
     cs = newCs
     // we need to re-initialize our entire context in order to have access to key store, decrypted data
     // etc with the new session...
@@ -608,7 +609,7 @@ export async function tyCore(
     chatCompletionStream: chatCompletionStream.stream,
     workerStream: workerStream.stream,
     taskStream: taskStream.stream,
-    workerStop: (message: string) => ctx.workerStop(message),
+    cancelCurrentRun: (message: string) => ctx.cancelCurrentRun(message),
     dispose: (message: string) => ctx.dispose(message),
     updateChatCompletionApiKey: async (key: string, value?: string) => {
       const { tool, def } = await ctx.taskManagerInstance.getToolDefinition(

packages/taskyon/src/core/taskWorker.ts

@@ -529,6 +529,8 @@ const setupRun = (
   const readyQueue = createAsyncQueue<string>()
   const pendingByPrior = new Map<string, Set<string>>()
   const activeTaskIds = new Set<string>()
+  const routingTasks = new Set<Promise<void>>()
+  const reconciliationTasks = new Set<Promise<void>>()
   const taskTracker = createTaskTracker(taskManager)
   let routingTaskCount = 0
   let didEmitAllProcessed = false
@@ -570,7 +572,7 @@ const setupRun = (
 
     didEmitAllProcessed = false
     routingTaskCount += 1
-    void (async () => {
+    const routingTask = (async () => {
       let wasRouted = false
       try {
         const task = await taskManager.getTask(id)
@@ -588,6 +590,11 @@ const setupRun = (
         if (!wasRouted) emitAllProcessedIfIdle()
       }
     })()
+    routingTasks.add(routingTask)
+    void routingTask.then(
+      () => routingTasks.delete(routingTask),
+      () => routingTasks.delete(routingTask),
+    )
   }
   const { taskisInLoop, taskOutOfLoop, getTasksInProgress, clearTasksInProgress } =
     workerLoggingHelper(streamEmit)
@@ -667,7 +674,12 @@ const setupRun = (
       if (getTasksInProgress() <= 0 && readyQueue.count() === 0 && pendingByPrior.size > 0) {
         streamEmit({ stage: 'waiting' })
       }
-      void reconcilePendingTasks().finally(() => emitAllProcessedIfIdle())
+      const reconciliationTask = reconcilePendingTasks().finally(() => emitAllProcessedIfIdle())
+      reconciliationTasks.add(reconciliationTask)
+      void reconciliationTask.then(
+        () => reconciliationTasks.delete(reconciliationTask),
+        () => reconciliationTasks.delete(reconciliationTask),
+      )
     }, 1000)
 
     try {
@@ -679,6 +691,7 @@ const setupRun = (
     } finally {
       clearInterval(reconciliationInterval)
     }
+    await Promise.allSettled([...routingTasks, ...reconciliationTasks])
     readyQueue.clear()
     pendingByPrior.clear()
     activeTaskIds.clear()
@@ -728,8 +741,9 @@ export function runTaskWorker(
   >()
   let currentTaskCtrl: AbortController | undefined = new AbortController()
   let queueTask: ((id: string) => void) | undefined = undefined
+  const activeRuns = new Set<Promise<void>>()
 
-  const workerStop = (message: string) => {
+  const cancelCurrentRun = (message: string) => {
     currentTaskCtrl?.abort(message)
     // in case of any errors, especially if its an interrupt event we simply want to cancel everything :P
     // empty our task queue :)
@@ -739,7 +753,7 @@ export function runTaskWorker(
   }
 
   // we have put all our dependencies in restartable workers.
-  // if anyone calls the "workerStop" the function wil simply re-start the worker
+  // If the current run is cancelled, the worker starts a new run when another task is queued.
   // as soon as a new task was added....
   const externalQueueTask = (id: string) => {
     if (currentTaskCtrl?.signal.aborted || !queueTask) {
@@ -751,14 +765,25 @@ export function runTaskWorker(
       currentTaskCtrl = newTaskCtrl
       queueTask = newQueueTask
 
-      void run(defaultTask, errorTask)
+      const workerRun = run(defaultTask, errorTask)
+      activeRuns.add(workerRun)
+      void workerRun.then(
+        () => activeRuns.delete(workerRun),
+        (error) => {
+          activeRuns.delete(workerRun)
+          taskProcessingStream.emit({ stage: 'error', info: humanizeError(error) })
+        },
+      )
     }
     queueTask(id)
   }
   return {
     workerStream: taskProcessingStream.stream,
     toolRpcPort,
-    workerStop,
+    cancelCurrentRun,
+    workerSettled: async () => {
+      await Promise.allSettled(activeRuns)
+    },
     queueTask: externalQueueTask,
   }
 }

packages/taskyon/src/taskyon.space/taskyon.space_api.ts

@@ -52,8 +52,7 @@ export async function returnToken(
 ) {
   const url = `${baseUrl}/return`
 
-  console.log('[returnToken] Returning token with data:', {
-    token,
+  console.log('[returnToken] Returning token usage data:', {
     credits_spent_increase,
     reference_data,
   })