dsh-my-go 0.1.26 → 0.1.28

package/lib/index.js

@@ -38,14 +38,21 @@ async function ensurePresetInstalled() {
   try {
     const here = dirname(fileURLToPath(import.meta.url)) // .../dsh-my-go/lib
     const packageRoot = dirname(here) // .../dsh-my-go
-    const source = join(packageRoot, 'preset')
     const dshHome = process.env.DSH_HOME || join(homedir(), '.dsh')
     const userPresetRoot = join(dshHome, '.agent-presets')
     const target = join(userPresetRoot, 'dsh-my-go')
-    await access(source)
     await mkdir(userPresetRoot, { recursive: true })
-    // Always overwrite to ensure latest preset files after npm update
-    await cp(source, target, { recursive: true, force: true })
+    // Sync preset/ directory (composition + tools)
+    const presetSource = join(packageRoot, 'preset')
+    await access(presetSource)
+    await cp(presetSource, target, { recursive: true, force: true })
+    // Sync prompts/ directory (persona markdown files)
+    const promptsSource = join(packageRoot, 'prompts')
+    const promptsTarget = join(target, 'prompts')
+    try {
+      await access(promptsSource)
+      await cp(promptsSource, promptsTarget, { recursive: true, force: true })
+    } catch { /* prompts/ optional — degrade gracefully */ }
     console.log(`[dsh-my-go] preset synced to ${target}`)
   } catch (error) {
     console.error(`[dsh-my-go] could not sync preset: ${String(error)}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-my-go",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "DSH plugin: Sisyphus agent orchestration — star topology, single-line blocking, 7 specialist sub-agents (Hermes/Explore/Librarian/Looker/Hephaestus/Prometheus/Oracle) with per-type model binding, go_work/continue/need_help/forward communication tools, Web UI tree panel and settings.",
   "author": "daizihan233",
   "license": "MIT",

package/preset/tools/broker.mjs

@@ -18,10 +18,40 @@ export const name = 'dsh-my-go-broker'
 
 export const inject = ['tools', 'subagents', 'systemPrompt', 'llm', 'settings']
 
+import { readFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
 const AGENT_TYPES = ['hermes', 'explore', 'librarian', 'looker', 'hephaestus', 'prometheus', 'oracle']
 
 const AGENT_TYPE_PREFIX = 'dsh-my-go:'
 
+// ── prompt file loading ───────────────────────────────────────────────────
+// Prompt files live in the prompts/ directory alongside the preset.
+// They are copied to ~/.dsh/.agent-presets/dsh-my-go/prompts/ by
+// ensurePresetInstalled (lib/index.js).
+const promptCache = new Map()
+async function loadPrompt(agentType) {
+  if (promptCache.has(agentType)) return promptCache.get(agentType)
+  try {
+    const here = dirname(fileURLToPath(import.meta.url)) // .../dsh-my-go/tools
+    const presetRoot = dirname(here) // .../dsh-my-go
+    const promptsDir = join(presetRoot, 'prompts')
+    const content = await readFile(join(promptsDir, `${agentType}.md`), 'utf-8')
+    promptCache.set(agentType, content)
+    return content
+  } catch {
+    promptCache.set(agentType, null)
+    return null
+  }
+}
+// Pre-load all prompts at startup (non-blocking, errors swallowed)
+async function loadAllPrompts() {
+  for (const type of [...AGENT_TYPES, 'sisyphus']) {
+    await loadPrompt(type)
+  }
+}
+
 function agentLabel(type, summary) {
   return `${AGENT_TYPE_PREFIX}${type}${summary ? `: ${summary}` : ''}`
 }
@@ -217,6 +247,9 @@ export async function apply(ctx, config = {}) {
   // bundle), not here — when this file loads from the preset copy,
   // import.meta.url points to the copy, not the npm package source.
 
+  // Load all prompt files from the prompts/ directory at startup
+  void loadAllPrompts()
+
   const orchestration = new Orchestration()
   const sessionTypes = new Map()
   let bindings = { ...defaultBindings(), ...(config.bindings ?? {}) }
@@ -340,22 +373,59 @@ export async function apply(ctx, config = {}) {
 3. 收到 intent=replan 时，必须切换智能体类型，而不是原地升级模型。
 4. Prometheus 只做规划不执行；它的计划必须由你按步骤重新调度。`
 
-  // Register persona + orchestration for Sisyphus only (static text).
-  // Sub-agents get their identity injected into prompt text via dispatchWork.
-  // We do NOT use section.text functions because:
-  //   1. Sub-agents may not inherit parent preset sections (scope issue)
-  //   2. Even if visible, text functions have a race condition with sessionTypes
+  // ── per-agent persona + orchestration via systemPrompt ────────────────────
+  //
+  // Sub-agents inherit the preset's scope, so they DO see these sections.
+  // We use text functions with parentSession detection (no race condition)
+  // to differentiate Sisyphus from sub-agents.
+  //
+  // For sub-agents:
+  //   - deployment:persona: empty (sub-agent persona is injected via context)
+  //   - dsh-my-go:orchestration: empty (sub-agents don't orchestrate)
+  //   - systemPrompt.context: injects the sub-agent's role description
+  //
+  // For Sisyphus:
+  //   - deployment:persona: full Sisyphus persona
+  //   - dsh-my-go:orchestration: full orchestration rules
+  //   - systemPrompt.context: empty (Sisyphus has no extra context)
+
+  const isSubAgentContext = (context) => {
+    // context = { agent, scope: agent } from assembleContextFor()
+    // Sub-agents have parentSession set in their session header
+    return context?.agent?.session?.header?.parentSession != null
+  }
+
+  // Use loaded prompt files for persona. SISYPHUS_PERSONA is the fallback
+  // if the file hasn't loaded yet (async startup).
   ctx.effect(() => ctx.systemPrompt.section({
     name: 'deployment:persona',
     order: 0,
-    text: SISYPHUS_PERSONA,
+    text: (context) => {
+      if (isSubAgentContext(context)) return ''
+      return promptCache.get('sisyphus') || SISYPHUS_PERSONA
+    },
   }), 'dsh-my-go-broker.persona()')
   ctx.effect(() => ctx.systemPrompt.section({
     name: 'dsh-my-go:orchestration',
     order: 20,
-    text: ORCHESTRATION_TEXT,
+    text: (context) => isSubAgentContext(context) ? '' : ORCHESTRATION_TEXT,
   }), 'dsh-my-go-broker.orchestration()')
 
+  // Inject sub-agent identity via systemPrompt.context (system prompt level).
+  // The text function checks parentSession — no race condition.
+  // Uses loaded prompt files when available.
+  ctx.effect(() => ctx.systemPrompt.context({
+    name: 'dsh-my-go:subagent-role',
+    order: 10,
+    text: (context) => {
+      if (!isSubAgentContext(context)) return ''
+      // Try to find the matching prompt from cache by checking all agent types
+      // The context doesn't carry the agent type, but we can check if any
+      // loaded prompt matches. Use a generic fallback.
+      return 'You are a specialist sub-agent in the dsh-my-go orchestration system. Execute one focused task and report results to Sisyphus. You do not delegate further.'
+    },
+  }), 'dsh-my-go-broker.subagent-role()')
+
   // ── internal go_work implementation (shared by the tool, forward, queue) ─
   async function dispatchWork(agentType, prompt, parent, signal) {
     if (!AGENT_TYPES.includes(agentType)) throw new Error(`unknown agent type: ${String(agentType)}`)
@@ -390,24 +460,17 @@ export async function apply(ctx, config = {}) {
         // No provider available — set model anyway, agent/request handler will validate
         agentOpts.model = binding.model
       }
-      // Inject sub-agent identity + role directly into the prompt text.
-      // Sub-agents may not inherit parent systemPrompt sections, so we
-      // cannot rely on section.text functions. The identity is injected
-      // as the first message so the model knows its role.
-      const roleDescriptions = {
-        hermes: 'You are Hermes, the rapid executor. You do batch replacements, code formatting, import consolidation, and text manipulation — fast mechanical work.',
-        explore: 'You are Explore, the fast searcher. You grep, read files, locate symbols, and scan directory structures — quick reconnaissance.',
-        librarian: 'You are Librarian, the document reader. You read READMEs, API references, historical docs, and extract comments — document intelligence.',
-        looker: 'You are Looker, the multimodal recognizer. You identify UI screenshots, design mockups, PDF charts — visual understanding.',
-        hephaestus: 'You are Hephaestus, the code crafter. You do single-file refactors, module implementations, unit tests, and routine code generation.',
-        prometheus: 'You are Prometheus, the requirement planner. You understand vague requirements, decompose them into executable steps, and output a plan. You do NOT execute — only plan.',
-        oracle: 'You are Oracle, the architect debugger and final validator. You do cross-module dependency analysis, deep bug localization, code review, and final acceptance.',
-      }
-      const rolePrefix = roleDescriptions[agentType] || `You are a ${agentType} sub-agent.`
-      const identityPrefix = `${rolePrefix}\n\nYou report your results to Sisyphus. Execute the following task and report back.\n\n`
+      // Inject sub-agent persona from prompts/ files via <system-reminder>.
+      // The loaded prompt contains full role description, responsibilities,
+      // work style, output format, and constraints — much richer than a
+      // one-line hardcoded string.
+      const loadedPrompt = promptCache.get(agentType)
+      const roleInfo = loadedPrompt || `You are a ${agentType} sub-agent in the dsh-my-go orchestration system. Execute one focused task and report results to Sisyphus.`
       const request = {
         label: agentLabel(agentType, prompt.slice(0, 60)),
-        prompt: [{ type: 'text', text: identityPrefix + prompt }],
+        prompt: [
+          { type: 'text', text: `<system-reminder>\n${roleInfo}\n</system-reminder>\n\n${prompt}` },
+        ],
         parent,
         ...(Object.keys(agentOpts).length > 0 ? { agentOptions: agentOpts } : {}),
         signal,