@p-dsh-market/graph-job-orchestrator 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# Graph Job 多 Subagent 任务图
+
+`@p-dsh-market/graph-job-orchestrator` 实现评审稿中的阶段 0～4 基础闭环：
+
+- Graph Draft/Revision、Agent Profile snapshot、DAG validator、静态并行预览、受限 Planner patch；
+- `%LOCALAPPDATA%/dsh-desktop/plugin-data/graph-job-orchestrator/` 下的原子 JSON 与 append-only JSONL 存储；
+- DSH in-process Subagent executor、merge barrier、read 并行/write 串行、失败暂停、有限 transport/rate-limit retry、取消和终止；
+- `artifactRefs` workspace-relative 校验、插件 Skill/Graph Job 递归保护、`/graphjob` 命令、Web API、SSE 和任务图编辑面板；
+- Codex provider 的能力发现、model/reasoningEffort 快照与 capability mismatch 错误。
+
+运行时必须先安装并注册 Codex Subagent provider，阶段 4 才会显示 Codex executor 可用；没有 provider 时不会伪装成可运行，而是在能力快照和运行错误中明确说明。当前仓库的本地 runtime 只有 DSH `spawn/fork` provider，因此不会在安装插件时自动修改 profile。
+
+需要 Codex 时，在目标 DSH profile 安装官方 provider Bundle 后重启该 profile：
+
+```powershell
+dsh plugin --profile <name> add @deepseek-ai/dsh-subagent-codex
+```
+
+插件只负责发现和校验 provider，不会代替用户安装 Bundle、登录 Codex 或修改 Codex 原生权限配置。
+
+主要端点：
+
+- `GET /graph-job-orchestrator/capabilities`
+- `GET/PUT /graph-job-orchestrator/profiles`
+- `GET/POST/PATCH /graph-job-orchestrator/graphs`
+- `POST /graph-job-orchestrator/graphs/:id/preview|confirm|run`
+- `GET /graph-job-orchestrator/graphs/:id/preview/:previewId`
+- `GET /graph-job-orchestrator/templates`
+- `GET /graph-job-orchestrator/templates/previews/:previewId`
+- `POST /graph-job-orchestrator/templates/preview|confirm|bind`
+- `GET /graph-job-orchestrator/runs/:runId/events`
+- `POST /graph-job-orchestrator/runs/:runId/retry|cancel|terminate`
+
+Planner 只接受当前会话的 roster、Graph JSON Schema 和受限 patch；候选图必须先 preview，再由用户确认。已有手工锁定图时，Planner 请求必须明确 `templateMode: "saveAs"` 或 `"overwrite"`，不会隐式改写当前模板。运行时输出严格投影为 `text` 和 `artifactRefs`，子会话 ID 只保存在运行状态和事件中。
+
+模板 manifest 支持 `scope: "workspace" | "global"`，默认是当前 workspace；workspace 模板不会出现在其他工作区的模板列表中。切换模板会创建新的 Graph Instance，不会把可变模板文件直接绑定为活动 Graph。
+
+验证命令：
+
+```powershell
+npm run check:graph-job
+npm test
+npm run catalog:validate
+Push-Location market/graph-job-orchestrator
+npm pack --dry-run --json
+Pop-Location
+```

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+- insert:
+    - id: p-dsh-market-graph-job-orchestrator
+      name: '@p-dsh-market/graph-job-orchestrator'
+      inject: [agentDefaultModel, agentPresets, agents, commands, llm, sessions, skills, subagents, systemPrompt, tools, webServer]

package/lib/capabilities.js

@@ -0,0 +1,216 @@
+import { GRAPH_SCHEMA_VERSION } from './graph-schema.js'
+
+async function callService(service, method, ...args) {
+  const fn = service?.[method]
+  if (typeof fn !== 'function') return undefined
+  try {
+    return await fn.call(service, ...args)
+  } catch {
+    return undefined
+  }
+}
+
+function asArray(value) {
+  if (Array.isArray(value)) return value
+  if (Array.isArray(value?.items)) return value.items
+  if (Array.isArray(value?.providers)) return value.providers
+  if (Array.isArray(value?.models)) return value.models
+  if (Array.isArray(value?.skills)) return value.skills
+  return []
+}
+
+function stringArray(value) {
+  if (typeof value === 'string') return value.trim() ? [value.trim()] : []
+  return Array.isArray(value) ? value.map((item) => String(item || '').trim()).filter(Boolean) : []
+}
+
+function providerOf(item) {
+  return String(item?.provider || item?.providerName || item?.sourceProvider || '').trim()
+}
+
+export function isPluginSkill(candidate = {}) {
+  return Boolean(
+    candidate.metadata?.plugin ||
+    candidate.plugin ||
+    candidate.metadata?.group === 'market' ||
+    providerOf(candidate) === 'desktop-skills' ||
+    /^@p-dsh-market\//i.test(providerOf(candidate)) ||
+    /graph-job-orchestrator/i.test(providerOf(candidate)) ||
+    ['plugin', 'market', 'desktop-plugin'].includes(String(candidate.source || '').toLowerCase())
+  )
+}
+
+export function normalizeSkillCandidate(candidate = {}) {
+  if (typeof candidate === 'string') candidate = { name: candidate }
+  const plugin = isPluginSkill(candidate)
+  const source = String(candidate.source || '').trim()
+  const provider = providerOf(candidate)
+  let origin = 'unknown'
+  if (plugin) origin = 'plugin'
+  else if (['runtime', 'builtin', 'user', 'workspace', 'local', 'project-dsh', 'project-agents', 'user-dsh', 'user-agents', 'bundled'].includes(source.toLowerCase())) {
+    const normalizedSource = source.toLowerCase()
+    if (['local', 'project-dsh', 'project-agents'].includes(normalizedSource)) origin = 'workspace'
+    else if (['user-dsh', 'user-agents'].includes(normalizedSource)) origin = 'user'
+    else if (normalizedSource === 'bundled') origin = 'runtime'
+    else origin = normalizedSource
+  }
+  else if (provider === 'runtime' || provider === 'builtin') origin = provider
+  const name = String(candidate.name || candidate.id || '').trim()
+  return {
+    name,
+    description: String(candidate.description || '').trim(),
+    source,
+    provider,
+    origin,
+    allowed: origin !== 'plugin' && origin !== 'unknown',
+    metadata: candidate.metadata && typeof candidate.metadata === 'object' ? { ...candidate.metadata } : undefined,
+    locator: candidate.locator || undefined,
+    path: candidate.path || undefined
+  }
+}
+
+export function filterSkills(candidates, allowlist = []) {
+  const allowedNames = new Set(stringArray(allowlist))
+  const normalized = (Array.isArray(candidates) ? candidates : []).map(normalizeSkillCandidate).filter((item) => item.name)
+  const allowed = normalized.filter((item) => allowedNames.has(item.name) && item.allowed)
+  const denied = normalized.filter((item) => !allowedNames.has(item.name) || !item.allowed)
+  return { allowed, denied }
+}
+
+function normalizeToolName(item) {
+  if (typeof item === 'string') return item.trim()
+  return String(item?.name || item?.id || item?.key || '').trim()
+}
+
+async function listTools(tools) {
+  const values = await callService(tools, 'schemas') ?? await callService(tools, 'list') ?? await callService(tools, 'getAll')
+  return [...new Set(asArray(values).map(normalizeToolName).filter(Boolean))].sort()
+}
+
+async function listSkills(skills, cwd) {
+  // dsh-skill accepts an optional cwd and defaults to the union of its
+  // registered layers. Do not invent a scope key here: the runtime's scope
+  // type is intentionally not the string "all".
+  const values = await callService(skills, 'list', { cwd }) ?? await callService(skills, 'list')
+  return asArray(values).map(normalizeSkillCandidate).filter((item) => item.name)
+}
+
+function providerCapabilities(item) {
+  const value = item?.capabilities || item?.capability || {}
+  return {
+    outputSchema: Boolean(value.outputSchema),
+    depthLimit: Boolean(value.depthLimit),
+    toolFilter: Boolean(value.toolFilter),
+    skillFilter: Boolean(value.skillFilter),
+    persona: Boolean(value.persona),
+    permissionMode: Boolean(value.permissionMode || value.permissionModes),
+    permissionModes: stringArray(value.permissionModes),
+    reasoningEfforts: stringArray(value.reasoningEfforts || value.reasoningEffort)
+  }
+}
+
+function normalizeProvider(item) {
+  if (typeof item === 'string') return { name: item, capabilities: {} }
+  return {
+    name: String(item?.name || item?.id || item?.providerName || '').trim(),
+    inheritsParentContext: item?.inheritsParentContext === true,
+    models: asArray(item?.models || item?.capabilities?.models).map((model) => typeof model === 'string' ? model : String(model?.id || model?.name || '').trim()).filter(Boolean),
+    capabilities: providerCapabilities(item)
+  }
+}
+
+async function listSubagentProviders(subagents) {
+  const values = asArray(await callService(subagents, 'list'))
+  const result = []
+  for (const item of values) {
+    const name = typeof item === 'string' ? item.trim() : String(item?.name || item?.id || item?.providerName || '').trim()
+    if (!name) continue
+    const descriptor = typeof item === 'object' ? item : await callService(subagents, 'getProvider', name)
+    result.push(normalizeProvider({ ...(descriptor || {}), name }))
+  }
+  return result
+}
+
+function extractReasoningEfforts(value) {
+  if (!value || typeof value !== 'object') return []
+  return stringArray(value.reasoningEfforts || value.reasoningEffort || value.capabilities?.reasoningEfforts || value.capabilities?.reasoningEffort)
+}
+
+async function discoverModels(llm) {
+  const providers = asArray(await callService(llm, 'listProviders'))
+  const result = []
+  for (const providerEntry of providers) {
+    const provider = typeof providerEntry === 'string' ? providerEntry : String(providerEntry?.name || providerEntry?.id || '').trim()
+    if (!provider) continue
+    const models = asArray(await callService(llm, 'listModels', provider))
+    for (const modelEntry of models) {
+      const model = typeof modelEntry === 'string' ? modelEntry : String(modelEntry?.id || modelEntry?.name || '').trim()
+      if (model) result.push({ provider, model, reasoningEfforts: extractReasoningEfforts(modelEntry) })
+    }
+  }
+  return result
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value
+  for (const child of Object.values(value)) deepFreeze(child)
+  return Object.freeze(value)
+}
+
+export async function buildCapabilityCatalog(options = {}) {
+  const cwd = String(options.cwd || '').trim()
+  const selection = await callService(options.agentDefaultModel, 'currentSelection') || {}
+  const defaultModel = {
+    provider: String(selection.provider || selection.providerName || '').trim(),
+    model: String(selection.model || selection.modelName || '').trim(),
+    reasoningEffort: String(selection.reasoningEffort || '').trim()
+  }
+  const subagentProviders = await listSubagentProviders(options.subagents)
+  const skills = await listSkills(options.skills, cwd)
+  const tools = await listTools(options.tools)
+  const models = await discoverModels(options.llm)
+  const codexProviders = subagentProviders.filter((item) => /codex/i.test(item.name))
+  const codexReasoning = [...new Set(codexProviders.flatMap((item) => item.capabilities.reasoningEfforts))]
+  const modelReasoning = models.flatMap((item) => item.reasoningEfforts)
+  const reasoningEfforts = [...new Set([...codexReasoning, ...modelReasoning])]
+  const catalog = {
+    schemaVersion: GRAPH_SCHEMA_VERSION,
+    capturedAt: Date.now(),
+    runtimeVersion: String(options.runtimeVersion || process.env.DSH_RUNTIME_VERSION || 'unknown'),
+    defaultModel,
+    executors: {
+      dsh: {
+        available: typeof options.agents?.create === 'function' || subagentProviders.some((item) => item.name === 'spawn'),
+        provider: subagentProviders.find((item) => item.name === 'spawn')?.name || 'spawn'
+      },
+      codex: {
+        available: codexProviders.length > 0,
+        providers: codexProviders.map((item) => item.name),
+        reasoningEfforts
+      }
+    },
+    subagentProviders,
+    models,
+    tools,
+    skills,
+    skillPolicy: {
+      allowlist: 'explicit',
+      pluginSkills: 'deny',
+      unknownSource: 'deny',
+      runtimeFallback: 'deny-all-when-scoped-filter-unavailable'
+    },
+    recursionGuard: {
+      deniedTools: ['graphjob_plan', 'graphjob_run', 'graphjob_patch', 'graph_job'],
+      deniedSkillOrigins: ['plugin', 'unknown']
+    }
+  }
+  return deepFreeze(catalog)
+}
+
+export function profileSkillSelection(catalog, names = []) {
+  const { allowed, denied } = filterSkills(catalog?.skills || [], names)
+  return {
+    names: allowed.map((item) => item.name).sort(),
+    denied: denied.map((item) => ({ name: item.name, origin: item.origin, source: item.source }))
+  }
+}