@goodandready/dsh-agent-orchestrator 0.1.9 → 0.1.10

package/lib/client.js

@@ -897,7 +897,14 @@ window.__ModuleLoader__.load({
           if (res.ok) {
             const data = await res.json()
             const active = (data.activePipelines || [])[0] || null
-            setActivePipeline(active)
+            setActivePipeline((prev) => {
+              if (!prev && !active) return null
+              if (!prev || !active) return active
+              if (prev.pipelineId === active.pipelineId && prev.status === active.status && prev.durationMs === active.durationMs) {
+                return prev
+              }
+              return active
+            })
 
             // If no active, check recent completed/failed within last 60 seconds
             if (!active && data.recentPipelines && data.recentPipelines.length > 0) {
@@ -917,12 +924,14 @@ window.__ModuleLoader__.load({
         }
       }, [dismissedId])
 
+      const hasActive = Boolean(activePipeline)
+
       useEffect(() => {
         pollStatus()
-        const intervalMs = activePipeline ? 2000 : 5000
+        const intervalMs = hasActive ? 2000 : 5000
         const timer = setInterval(pollStatus, intervalMs)
         return () => clearInterval(timer)
-      }, [activePipeline, pollStatus])
+      }, [hasActive, pollStatus])
 
       const handleCancel = async (pipelineId) => {
         try {

package/lib/index.js

@@ -292,10 +292,22 @@ export function apply(ctx, config = {}) {
     }
   }
 
+  const activeAbortControllers = new Map()
+
   /**
    * Runner object to start, execute, and monitor pipelines
    */
   const runner = {
+    cancelPipeline(pipelineId) {
+      const controller = activeAbortControllers.get(pipelineId)
+      if (controller) {
+        controller.abort()
+        activeAbortControllers.delete(pipelineId)
+        return true
+      }
+      return false
+    },
+
     async startPipeline({ taskTitle, taskDescription, scenarioId, taskId }) {
       const cfg = getConfig()
       const plan = decomposeTask({
@@ -369,17 +381,24 @@ export function apply(ctx, config = {}) {
         }
       }
 
+      const abortController = new AbortController()
+      activeAbortControllers.set(plan.pipelineId, abortController)
+
       executeDAG({
         stages: plan.stages,
         executor,
         concurrency: 3,
+        signal: abortController.signal,
       })
         .then(async (dagResult) => {
-          store.updatePipeline(plan.pipelineId, {
-            status: 'completed',
-            completedAt: Date.now(),
+          activeAbortControllers.delete(plan.pipelineId)
+          const currentP = store.getPipeline(plan.pipelineId)
+          if (currentP?.status === 'failed' && currentP?.error === 'Cancelled by user') {
+            return
+          }
+          store.recordCompletion(plan.pipelineId, {
+            ...dagResult,
             durationMs: Date.now() - pipelineData.startedAt,
-            artifacts: dagResult.artifacts,
           })
 
           // Sync to Kanban if enabled
@@ -399,7 +418,7 @@ export function apply(ctx, config = {}) {
                 if (syncConfig.createChecklist) {
                   const checklistItems = plan.stages.map((s) => ({
                     title: `${s.name} (${s.roleName})`,
-                    completed: dagResult.statusMap[s.id] === 'completed',
+                    completed: dagResult?.stateMap?.[s.id]?.status === 'completed',
                   }))
                   await kanbanBridge.syncStageChecklist(targetTaskId, checklistItems)
                 }
@@ -419,7 +438,7 @@ export function apply(ctx, config = {}) {
               id: plan.pipelineId,
               title: plan.taskTitle,
               scenarioId: plan.scenarioId,
-              status: dagResult.allSucceeded ? 'completed' : 'failed',
+              status: dagResult?.success ? 'completed' : 'failed',
               stages: plan.stages,
               durationMs: Date.now() - pipelineData.startedAt,
             })
@@ -428,9 +447,13 @@ export function apply(ctx, config = {}) {
           }
         })
         .catch((dagErr) => {
-          store.updatePipeline(plan.pipelineId, {
-            status: 'failed',
-            completedAt: Date.now(),
+          activeAbortControllers.delete(plan.pipelineId)
+          const currentP = store.getPipeline(plan.pipelineId)
+          if (currentP?.status === 'failed' && currentP?.error === 'Cancelled by user') {
+            return
+          }
+          store.recordCompletion(plan.pipelineId, {
+            success: false,
             durationMs: Date.now() - pipelineData.startedAt,
             error: dagErr?.message || String(dagErr),
           })
@@ -813,8 +836,11 @@ export function apply(ctx, config = {}) {
     }
   }
 
+  let hasCommandsService = false
+
   // Chat slash commands: /orchestrate and /orc via commands service
   ctx.inject(['commands'], (cctx) => {
+    hasCommandsService = true
     try {
       if (typeof cctx.commands?.register !== 'function') return
 
@@ -904,6 +930,7 @@ export function apply(ctx, config = {}) {
 
       if (typeof cctx.effect === 'function') {
         cctx.effect(() => () => {
+          hasCommandsService = false
           try {
             if (typeof unregister1 === 'function') unregister1()
             if (typeof unregister2 === 'function') unregister2()
@@ -938,6 +965,11 @@ export function apply(ctx, config = {}) {
       const text = String(event.text || event.content || '').trim()
       const intent = detectOrchestratorIntent(text)
 
+      // Prevent duplicate dispatch: if commands service is active, slash commands are handled by cctx.commands (#148)
+      if (hasCommandsService && intent.triggerKind === 'slash') {
+        return
+      }
+
       if (intent.isTrigger && intent.action === 'on') {
         await handlePipelineDispatch({
           taskTitle: intent.taskTitle || 'Interactive Orchestrated Task',

package/lib/pipeline/dag-engine.js

@@ -149,12 +149,14 @@ export async function executeDAG(stagesOrOptions, executorArg, optionsArg = {})
   let onNodeComplete = () => {}
   let onNodeFail = () => {}
   let onNodeBlocked = () => {}
+  let signal = null
 
   if (Array.isArray(stagesOrOptions)) {
     stages = stagesOrOptions
     executor = executorArg
     concurrency = optionsArg.concurrency || optionsArg.maxConcurrency || 4
     initialContext = optionsArg.initialContext || {}
+    signal = optionsArg.signal || null
     if (typeof optionsArg.onNodeStart === 'function') onNodeStart = optionsArg.onNodeStart
     if (typeof optionsArg.onNodeComplete === 'function') onNodeComplete = optionsArg.onNodeComplete
     if (typeof optionsArg.onNodeFail === 'function') onNodeFail = optionsArg.onNodeFail
@@ -164,6 +166,7 @@ export async function executeDAG(stagesOrOptions, executorArg, optionsArg = {})
     executor = stagesOrOptions.executor
     concurrency = stagesOrOptions.concurrency || stagesOrOptions.maxConcurrency || 4
     initialContext = stagesOrOptions.initialContext || {}
+    signal = stagesOrOptions.signal || null
     if (typeof stagesOrOptions.onNodeStart === 'function') onNodeStart = stagesOrOptions.onNodeStart
     if (typeof stagesOrOptions.onNodeComplete === 'function') onNodeComplete = stagesOrOptions.onNodeComplete
     if (typeof stagesOrOptions.onNodeFail === 'function') onNodeFail = stagesOrOptions.onNodeFail
@@ -220,13 +223,33 @@ export async function executeDAG(stagesOrOptions, executorArg, optionsArg = {})
     function triggerNext() {
       if (isDone) return
 
+      if (signal?.aborted) {
+        if (!isDone && runningCount === 0) {
+          isDone = true
+          for (const s of stages) {
+            const st = stateMap.get(s.id)
+            if (st.status === NODE_STATUS.PENDING) {
+              st.status = NODE_STATUS.SKIPPED
+            }
+          }
+          resolvePromise({
+            success: false,
+            cancelled: true,
+            durationMs: Date.now() - startTime,
+            stateMap: Object.fromEntries(stateMap),
+            artifacts: Object.fromEntries(artifacts),
+          })
+        }
+        return
+      }
+
       // Propagate blockers first
       if (markBlockedStages(stages, stateMap)) {
         for (const s of stages) {
           const st = stateMap.get(s.id)
           if (st.status === NODE_STATUS.BLOCKED && !st.notifiedBlocked) {
             st.notifiedBlocked = true
-            onNodeBlocked(st)
+            try { onNodeBlocked(st) } catch (_) { /* Safe ignore notification error */ }
           }
         }
       }
@@ -241,7 +264,7 @@ export async function executeDAG(stagesOrOptions, executorArg, optionsArg = {})
         nodeState.startedAt = Date.now()
         runningCount++
 
-        onNodeStart(nodeState)
+        try { onNodeStart(nodeState) } catch (_) { /* Safe ignore notification error */ }
 
         // Run task asynchronously
         const upstreamOutputs = {}
@@ -266,17 +289,28 @@ export async function executeDAG(stagesOrOptions, executorArg, optionsArg = {})
 
             artifacts.set(nextStage.id, nodeState.output)
             runningCount--
-            onNodeComplete(nodeState)
+            try {
+              onNodeComplete(nodeState)
+            } catch (_) {
+              /* Callback error must not alter completed state or double-decrement runningCount */
+            }
             triggerNext()
           })
           .catch((err) => {
+            if (nodeState.status === NODE_STATUS.COMPLETED) {
+              return
+            }
             nodeState.status = NODE_STATUS.FAILED
             nodeState.completedAt = Date.now()
             nodeState.durationMs = nodeState.completedAt - nodeState.startedAt
             nodeState.error = err?.message || String(err)
 
             runningCount--
-            onNodeFail(nodeState, err)
+            try {
+              onNodeFail(nodeState, err)
+            } catch (_) {
+              /* Callback error must not crash the engine */
+            }
             triggerNext()
           })
       }
@@ -284,6 +318,12 @@ export async function executeDAG(stagesOrOptions, executorArg, optionsArg = {})
       checkCompletion()
     }
 
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        triggerNext()
+      }, { once: true })
+    }
+
     // Initial trigger
     triggerNext()
   })

package/lib/pipeline/delegation.js

@@ -152,8 +152,18 @@ export function normalizeRoleId(input, availableRoles = []) {
     if (role.displayName && role.displayName.toLowerCase() === lower) return role.id
   }
 
+  function matchesRoleAlias(str, alias) {
+    if (str === alias) return true
+    if (alias.length <= 3) {
+      const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      const regex = new RegExp('(^|[^a-z0-9а-яё])' + escaped + '([^a-z0-9а-яё]|$)', 'i')
+      return regex.test(str)
+    }
+    return str.includes(alias)
+  }
+
   for (const [alias, id] of Object.entries(ROLE_INPUT_ALIASES)) {
-    if (lower === alias || lower.includes(alias)) {
+    if (matchesRoleAlias(lower, alias)) {
       const found = rolesList.find((r) => r.id === id)
       if (found) return found.id
       if (id === 'code') {

package/lib/pipeline/intent.js

@@ -51,12 +51,13 @@ export function detectOrchestratorIntent(text) {
   if (slashMatch) {
     const rest = (slashMatch[1] || '').trim()
     if (rest.toLowerCase() === 'off') {
-      return { isTrigger: true, action: 'off' }
+      return { isTrigger: true, action: 'off', triggerKind: 'slash' }
     }
     const { scenarioId, taskTitle } = extractScenarioAndTask(rest)
     return {
       isTrigger: true,
       action: 'on',
+      triggerKind: 'slash',
       scenarioId,
       taskTitle,
     }
@@ -73,6 +74,7 @@ export function detectOrchestratorIntent(text) {
     return {
       isTrigger: true,
       action: 'on',
+      triggerKind: 'nl',
       scenarioId,
       taskTitle,
     }
@@ -89,6 +91,7 @@ export function detectOrchestratorIntent(text) {
     return {
       isTrigger: true,
       action: 'on',
+      triggerKind: 'nl',
       scenarioId,
       taskTitle,
     }

package/lib/pipeline/model-selection.js

@@ -569,7 +569,6 @@ export async function fetchModelCatalog(ctx, options = {}) {
     const defaultPool = [
       { provider: 'deepseek-official', model: 'deepseek-chat', maxTokens: 4096 },
       { provider: 'deepseek-official', model: 'deepseek-reasoner', maxTokens: 8192 },
-      { provider: 'anthropic', model: 'claude-3-5-sonnet', maxTokens: 8192 },
     ]
     for (const item of defaultPool) {
       const capabilities = inferModelCapabilities(item.model, item.provider)

package/lib/pipeline/snapshots.js

@@ -23,6 +23,7 @@ export class SnapshotManager {
     this.baseDir = baseDir || path.join(os.homedir(), '.dsh', 'orchestrator-snapshots')
     this.maxSnapshots = maxSnapshots
     this.logger = logger || null
+    this._snapshotsCache = null
     this._ensureDir()
   }
 
@@ -65,6 +66,9 @@ export class SnapshotManager {
    */
   listSnapshots() {
     this._ensureDir()
+    if (this._snapshotsCache) {
+      return [...this._snapshotsCache]
+    }
     try {
       const files = fs.readdirSync(this.baseDir)
       const snapshots = []
@@ -91,7 +95,8 @@ export class SnapshotManager {
         return timeB - timeA
       })
 
-      return snapshots
+      this._snapshotsCache = snapshots
+      return [...snapshots]
     } catch (err) {
       if (this.logger?.error) {
         this.logger.error('[SnapshotManager] Error listing snapshots:', err?.message || err)
@@ -158,7 +163,7 @@ export class SnapshotManager {
     const tmpPath = path.join(this.baseDir, `${snapshotId}.tmp-${Date.now()}`)
 
     try {
-      fs.writeFileSync(tmpPath, JSON.stringify(record, null, 2), 'utf8')
+      fs.writeFileSync(tmpPath, JSON.stringify(record), 'utf8')
       fs.renameSync(tmpPath, filePath)
     } catch (err) {
       try {
@@ -169,6 +174,7 @@ export class SnapshotManager {
       throw err
     }
 
+    this._snapshotsCache = null
     // Enforce FIFO retention policy: if file count > maxSnapshots, prune oldest
     this._enforceRetention()
 
@@ -179,6 +185,7 @@ export class SnapshotManager {
    * Prunes oldest snapshot files when total exceeds maxSnapshots ceiling.
    */
   _enforceRetention() {
+    this._snapshotsCache = null
     try {
       const files = fs.readdirSync(this.baseDir).filter((f) => f.endsWith('.json'))
       if (files.length <= this.maxSnapshots) return

package/lib/pipeline/worker-pool.js

@@ -84,6 +84,7 @@ export async function executeStageWorker(stage, context) {
       output: artContent || '',
     })
   }
+  priorArtifactsList.sort((a, b) => a.stageId.localeCompare(b.stageId))
   const cumulativeArtifacts = formatCumulativeArtifacts(priorArtifactsList)
 
   // 4. Assemble canonical prompt (Layer 1 + 2 + 3 in System, Layer 4 in User)

package/lib/routes.js

@@ -29,6 +29,9 @@ export function registerOrchestratorRoutes(ctx, services) {
     kind: 'exact',
     path: '/dsh-agent-orchestrator/status',
     handler: (req, res) => {
+      if (req.method !== 'GET') {
+        return jsonReply(res, { error: 'Method not allowed' }, 405)
+      }
       jsonReply(res, {
         activePipelines: store.getActivePipelines(),
         metrics: store.getMetrics(),
@@ -112,6 +115,10 @@ export function registerOrchestratorRoutes(ctx, services) {
     kind: 'prefix',
     path: '/dsh-agent-orchestrator/pipeline',
     handler: (req, res) => {
+      if (req.method !== 'GET') {
+        return jsonReply(res, { error: 'Method not allowed' }, 405)
+      }
+      if (rejectUntrustedRequest(req, res)) return
       const parts = req.url.split('?')[0].split('/')
       const pipelineId = parts[parts.length - 1]
       const pipeline = store.getPipeline(pipelineId)
@@ -140,6 +147,7 @@ export function registerOrchestratorRoutes(ctx, services) {
       }
 
       const pipelineId = body.pipelineId
+      runner?.cancelPipeline?.(pipelineId)
       const p = store.getPipeline(pipelineId)
       if (p && (p.status === 'running' || p.status === 'pending')) {
         store.updatePipeline(pipelineId, {
@@ -178,6 +186,10 @@ export function registerOrchestratorRoutes(ctx, services) {
         await updateConfig(body)
         return jsonReply(res, { success: true, config: getConfig() })
       }
+      if (req.method !== 'GET') {
+        return jsonReply(res, { error: 'Method not allowed' }, 405)
+      }
+      if (rejectUntrustedRequest(req, res)) return
       jsonReply(res, { config: getConfig() })
     },
   }), 'dsh-agent-orchestrator: config route')
@@ -187,6 +199,9 @@ export function registerOrchestratorRoutes(ctx, services) {
     kind: 'exact',
     path: '/dsh-agent-orchestrator/models',
     handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        return jsonReply(res, { error: 'Method not allowed' }, 405)
+      }
       const selection = readModelSelection(ctx)
       const catalog = await fetchModelCatalog(ctx, {
         allowedRoutes: selection.allowedRoutes,
@@ -204,6 +219,9 @@ export function registerOrchestratorRoutes(ctx, services) {
     kind: 'exact',
     path: '/dsh-agent-orchestrator/catalog/models',
     handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        return jsonReply(res, { error: 'Method not allowed' }, 405)
+      }
       try {
         const urlObj = new URL(req.url, 'http://localhost')
         const provider = urlObj.searchParams.get('provider') || undefined
@@ -225,6 +243,10 @@ export function registerOrchestratorRoutes(ctx, services) {
     kind: 'exact',
     path: '/dsh-agent-orchestrator/snapshots',
     handler: (req, res) => {
+      if (req.method !== 'GET') {
+        return jsonReply(res, { error: 'Method not allowed' }, 405)
+      }
+      if (rejectUntrustedRequest(req, res)) return
       try {
         const snapshots = snapshotManager.listSnapshots()
         jsonReply(res, { snapshots, total: snapshots.length })

package/lib/store.js

@@ -12,9 +12,10 @@ export class OrchestratorStore {
   constructor(options = {}) {
     const opts = typeof options === 'string' ? { storageDir: options } : (options || {})
     const baseDir = opts.storageDir || join(homedir(), '.dsh')
-    this.storagePath = join(baseDir, 'orchestrator-pipelines.json')
+    this.storagePath = opts.storagePath || join(baseDir, 'orchestrator-pipelines.json')
     this.logger = opts.logger || null
     this.pipelines = new Map()
+    this._saveTimer = null
     this.globalMetrics = {
       totalPipelines: 0,
       completedPipelines: 0,
@@ -55,12 +56,23 @@ export class OrchestratorStore {
         globalMetrics: this.globalMetrics,
         updatedAt: Date.now(),
       }
-      writeFileSync(this.storagePath, JSON.stringify(serialized, null, 2), 'utf8')
+      writeFileSync(this.storagePath, JSON.stringify(serialized), 'utf8')
     } catch (e) {
       if (this.logger?.warn) this.logger.warn('[dsh-agent-orchestrator] Store save warning:', e?.message || e)
     }
   }
 
+  saveDebounced(delayMs = 150) {
+    if (this._saveTimer) return
+    this._saveTimer = setTimeout(() => {
+      this._saveTimer = null
+      this.save()
+    }, delayMs)
+    if (this._saveTimer && typeof this._saveTimer.unref === 'function') {
+      this._saveTimer.unref()
+    }
+  }
+
   recordPipeline(pipelineData) {
     this.pipelines.set(pipelineData.pipelineId, pipelineData)
     this.globalMetrics.totalPipelines++
@@ -107,7 +119,7 @@ export class OrchestratorStore {
       }
     }
 
-    this.save()
+    this.saveDebounced()
     return updated
   }
 
@@ -127,6 +139,7 @@ export class OrchestratorStore {
       p.durationMs = summary.durationMs || 0
       p.stateMap = summary.stateMap || {}
       p.artifacts = summary.artifacts || {}
+      if (summary.error) p.error = summary.error
 
       if (summary.success) {
         this.globalMetrics.completedPipelines++

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-agent-orchestrator",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Multi-agent task decomposition, DAG workflow orchestration, and prompt caching optimizer for DeepSeek Harness.",
   "type": "module",
   "main": "./lib/index.js",