archgraph-argo 0.26.2 → 0.27.0

package/install-argo.ps1

@@ -25,6 +25,9 @@ param(
     [string]$OpenClawWorkspace = "$env:USERPROFILE\.openclaw\workspace",
     [string]$OpenClawRepoRoot = '',
     [switch]$SkipOpenClaw,
+    [string]$DoubaoHome = "$env:USERPROFILE\Doubao",
+    [string]$DoubaoWorkspace = "$env:LOCALAPPDATA\Doubao\User Data\Default\.doubao\agent_mode\workspace",
+    [switch]$SkipDoubao,
     [string]$McpPath,
     [string]$GraphMcpUrl = 'https://argo.derekworkspacev5.com/mcp'
 )
@@ -298,16 +301,6 @@ function Get-MarkdownBody {
     return $m.Groups[2].Value
 }
 
-function Get-WakeupGuideline {
-    # Extract the <WakeupGuideline>...</WakeupGuideline> block from the rule
-    # text, so the DSH wakeup plugin is generated from the same source the
-    # Copilot / Cursor / OpenCode rules use.
-    param([string]$RuleText)
-    $m = [regex]::Match($RuleText, '(?s)<WakeupGuideline>(.*?)</WakeupGuideline>')
-    if (-not $m.Success) { return '' }
-    return $m.Groups[1].Value.Trim()
-}
-
 function Write-ArchGraphRuleBlock {
     # Merge the frontmatter-stripped ArchGraph rule into a target AGENTS.md
     # file (DSH home or OpenClaw workspace), replacing the previous ArchGraph
@@ -372,6 +365,149 @@ function Write-OpenClawAgentRule {
     Write-ArchGraphRuleBlock -DestPath (Join-Path $OpenClawWorkspace 'AGENTS.md') -RuleText $RuleText -Label 'OpenClaw rule'
 }
 
+function Convert-SkillFile {
+    # Normalize an ArchGraph SKILL.md for the Doubao (desktop agent mode) skill
+    # system. Doubao follows the Anthropic Agent Skills spec: the YAML
+    # frontmatter may contain ONLY `name` and `description` (see the built-in
+    # skill-creator-for-work skill); any other field is rejected. The ArchGraph
+    # skills additionally carry VS Code / OpenCode-only fields (argument-hint,
+    # disable-model-invocation), so strip the frontmatter down to name +
+    # description while keeping the body verbatim and the values byte-intact.
+    param(
+        [string]$SourceFile,
+        [string]$DestinationFile
+    )
+    $content = Get-Content $SourceFile -Raw -Encoding UTF8
+    $m = [regex]::Match($content, '(?s)^---\s*\r?\n(.*?)\r?\n---\s*\r?\n(.*)$')
+    if (-not $m.Success) {
+        Copy-Item -Force -Path $SourceFile -Destination $DestinationFile
+        return
+    }
+    $front = $m.Groups[1].Value
+    $body = $m.Groups[2].Value
+
+    $name = ''
+    $desc = ''
+    $nm = [regex]::Match($front, '(?m)^name:\s*(.*)$')
+    if ($nm.Success) { $name = $nm.Groups[1].Value.Trim().Trim('"').Trim("'") }
+    # Keep the description value verbatim (including any surrounding quotes) so
+    # non-ASCII and internal punctuation survive the round-trip byte-for-byte.
+    $dm = [regex]::Match($front, '(?m)^description:\s*(.*)$')
+    if ($dm.Success) { $desc = $dm.Groups[1].Value.Trim() }
+
+    $newFront = "---`r`n"
+    if ($name) { $newFront += "name: $name`r`n" }
+    if ($desc) { $newFront += "description: $desc`r`n" }
+    $newFront += "---`r`n"
+
+    $result = $newFront + "`r`n" + $body
+    [System.IO.File]::WriteAllText($DestinationFile, $result, (New-Object System.Text.UTF8Encoding $false))
+}
+
+function Copy-DoubaoSkills {
+    # Deploy the ArchGraph skills into a Doubao skill root. Doubao adopts the
+    # Anthropic Agent Skills layout: one folder per skill containing SKILL.md
+    # (plus optional scripts/references/assets). The metadata (name +
+    # description) is always in context; the body loads only when the skill
+    # triggers. SKILL.md is normalized via Convert-SkillFile; any bundled
+    # resources are copied verbatim so the skill folder is self-contained.
+    param(
+        [string]$Root,
+        [string]$SourceSkillsRoot,
+        [string[]]$SkillNames,
+        [string]$Label
+    )
+    foreach ($skill in $SkillNames) {
+        $src = Join-Path $SourceSkillsRoot $skill
+        if (-not (Test-Path (Join-Path $src 'SKILL.md'))) { continue }
+        $destDir = Join-Path $Root $skill
+        New-Item -ItemType Directory -Force -Path $destDir | Out-Null
+        Copy-Item -Recurse -Force -Path (Join-Path $src '*') -Destination $destDir
+        Convert-SkillFile -SourceFile (Join-Path $src 'SKILL.md') -DestinationFile (Join-Path $destDir 'SKILL.md')
+    }
+    Write-Host "  argo skills -> $Root ($Label)"
+}
+
+function Convert-RuleToSkill {
+    # Package the single-source ARGO rule file (argo/rules/archgraph.instructions.md)
+    # as a Doubao entry skill. Doubao keeps ONLY a skill's name + description in
+    # context permanently (the body loads when the skill triggers) and it
+    # forbids angle brackets in the description. So the frontmatter carries a
+    # mandatory trigger description (the STEP 0 gate + the "load before any
+    # intent-graph read/write" mandate) and the body is the rule text verbatim
+    # (frontmatter stripped). This is the closest Doubao allows to an always-on
+    # rule: Doubao has no system-prompt / AGENTS.md hook.
+    param(
+        [string]$RuleFile,
+        [string]$DestinationFile
+    )
+    $rule = Get-Content $RuleFile -Raw -Encoding UTF8
+    $body = Get-MarkdownBody -Content $rule
+    $description = 'MANDATORY entry skill for the ARGO / ArchGraph intent graph. Whenever the workspace is an ArchGraph workspace (contains design/KG/SystemArchitecture.json) or the argo MCP tools (mcp__argo__*) are available, you MUST load this skill BEFORE reading, querying or writing the architecture graph. STEP 0 gate: identify your Business Actor through the argo MCP and restore your working memory first, then follow this skill for KG-first retrieval, the ARGO red lines, acceptance-test-first work, deduplicated and lossless graph writes, and commit tracing.'
+    $front = "---`r`nname: archgraph-argo`r`ndescription: `"$description`"`r`n---`r`n"
+    [System.IO.File]::WriteAllText($DestinationFile, ($front + "`r`n" + $body), (New-Object System.Text.UTF8Encoding $false))
+}
+
+function Write-DoubaoMcpRecipe {
+    # Doubao's desktop agent mode registers MCP servers through its in-app UI
+    # (自定义连接器: 传输类型 STDIO / 命令 / 参数 / 环境变量), NOT through a config
+    # file, so the installer cannot auto-register. This writes the exact
+    # connector values to a reference file and prints a copy-paste recipe.
+    #
+    # The argo server is a local stdio child with NO fixed workspace: Doubao's
+    # MCP client (rmcp) supports the MCP `roots` handshake and passes a
+    # `workingDirectory` when spawning a stdio connector, so argo follows the
+    # workspace the user selected in Doubao - exactly like the OpenCode (roots)
+    # and DeepSeek Harness (injected workspaceRoot) hosts. ARGO_REPO_ROOT is
+    # therefore NOT pinned; it remains available as an optional override.
+    # graph-mcp (remote Streamable HTTP) is exposed through the same stdio
+    # bridge the Cursor deployment uses.
+    param(
+        [string]$RecipePath,
+        [string]$ArgoServer,
+        [string]$BridgePath,
+        [string]$GraphMcpUrl
+    )
+    $argoServerSlash = ($ArgoServer -replace '\\', '/')
+    $connectors = @(
+        [ordered]@{
+            serverName = 'argo'
+            transport  = 'STDIO'
+            command    = 'node'
+            args       = @($argoServerSlash)
+        }
+    )
+    if ($BridgePath) {
+        $connectors += [ordered]@{
+            serverName = 'graph-mcp'
+            transport  = 'STDIO'
+            command    = 'node'
+            args       = @(($BridgePath -replace '\\', '/'))
+            env        = [ordered]@{ GRAPH_MCP_URL = $GraphMcpUrl }
+        }
+    }
+    $recipe = [ordered]@{
+        host       = 'Doubao desktop (agent mode) - custom connector (自定义连接器), manual in-app registration'
+        note       = 'Open Doubao agent mode -> MCP/connector settings -> add a custom connector -> enter the values below (transport 传输类型 = STDIO). Requires Node.js on PATH. Doubao custom connectors run only on the local machine.'
+        workspace  = 'The argo connector has no fixed workspace: it follows the workspace selected in Doubao (MCP roots / connector workingDirectory), the same way OpenCode (roots) and DeepSeek Harness (injected workspaceRoot) do. To pin a fixed workspace instead, add env ARGO_REPO_ROOT=<absolute project path>.'
+        connectors = $connectors
+    }
+    New-Item -ItemType Directory -Force -Path (Split-Path $RecipePath) | Out-Null
+    [System.IO.File]::WriteAllText($RecipePath, ($recipe | ConvertTo-Json -Depth 8), (New-Object System.Text.UTF8Encoding $false))
+    Write-Host "  Doubao MCP connector recipe -> $RecipePath"
+    Write-Host '  Register once in the Doubao app (自定义连接器, 传输类型 STDIO):'
+    Write-Host '    服务器名称: argo'
+    Write-Host '    命令: node'
+    Write-Host "    参数: $argoServerSlash"
+    Write-Host '    (workspace: follows the workspace selected in Doubao)'
+    if ($BridgePath) {
+        Write-Host '    服务器名称: graph-mcp'
+        Write-Host '    命令: node'
+        Write-Host "    参数: $($BridgePath -replace '\\', '/')"
+        Write-Host "    环境变量: GRAPH_MCP_URL=$GraphMcpUrl"
+    }
+}
+
 function Write-OpenClawMcpConfig {
     # Register the argo MCP server under mcp.servers.argo in
     # ~/.openclaw/openclaw.json. OpenClaw is a fixed-workspace host: its
@@ -491,200 +627,51 @@ function Write-DshManagedBlock {
 }
 
 function New-DshWakeupPlugin {
-    # Generate the DSH wakeup-gate Cordis plugin under ~/.dsh/plugins from the
-    # <WakeupGuideline> block of the rule file. This is the DeepSeek Harness
-    # equivalent of the OpenCode hook plugin argo/plugins/argo-wakeup.js: it
-    # registers the gate as the first system-prompt section after the harness
-    # identity (order -100), before the deployment persona (order 0).
+    # Deploy the DSH wakeup-gate Cordis plugin under ~/.dsh/plugins by copying
+    # the single-source bundle artifact dsh-argo-wakeup/index.js (generated from
+    # the <WakeupGuideline> block of argo/rules/archgraph.instructions.md by
+    # scripts/gen-dsh-plugins.js). Copying - not regenerating a template here -
+    # keeps the deployed plugin and the shipped bundle byte-identical, so the
+    # gate text has exactly one source and cannot fork.
     param(
-        [string]$DshHome,
-        [string]$RuleText
+        [string]$DshHome
     )
-    $gate = Get-WakeupGuideline -RuleText $RuleText
-    if (-not $gate) {
-        Write-Warning '  <WakeupGuideline> not found in the rule file; DSH wakeup plugin skipped.'
+    $source = Join-Path (Join-Path $repoRoot 'dsh-argo-wakeup') 'index.js'
+    if (-not (Test-Path $source)) {
+        Write-Warning "  $source not found; DSH wakeup plugin skipped."
         return $null
     }
     $dir = Join-Path (Join-Path $DshHome 'plugins') 'dsh-argo-wakeup'
     New-Item -ItemType Directory -Force -Path $dir | Out-Null
-    $gateJson = $gate | ConvertTo-Json
-    $plugin = @"
-// dsh-argo-wakeup - generated by install-argo.ps1 from
-// argo/rules/archgraph.instructions.md (single source of truth: the rule file;
-// this file is a deployment artifact, do not edit by hand).
-// DeepSeek Harness equivalent of the OpenCode hook argo/plugins/argo-wakeup.js:
-// registers the unconditional wakeup gate as the first system-prompt section
-// after the harness identity, so every session identifies its Business Actor
-// through the argo MCP server before responding.
-export const name = 'dsh-argo-wakeup'
-export const inject = ['systemPrompt']
-const WAKEUP_GATE = $gateJson
-export function apply(ctx) {
-  ctx.effect(() => ctx.systemPrompt.section({
-    name: 'argo:wakeup',
-    order: -90,
-    text: WAKEUP_GATE,
-  }), 'argo:wakeup.section()')
-}
-"@
     $indexPath = Join-Path $dir 'index.js'
-    [System.IO.File]::WriteAllText($indexPath, $plugin, (New-Object System.Text.UTF8Encoding $false))
-    Write-Host "  DSH wakeup plugin generated -> $indexPath"
+    Copy-Item -Force -Path $source -Destination $indexPath
+    Write-Host "  DSH wakeup plugin <- $source (single source)"
     return $indexPath
 }
 
 function New-DshWorkspaceBridge {
-    # Generate the DSH workspace bridge plugin under ~/.dsh/plugins. It
-    # connects directly to the argo MCP server (no dsh-mcp-client row needed)
-    # with a zero-dependency minimal MCP stdio client, registers every tool as
+    # Deploy the DSH workspace bridge plugin under ~/.dsh/plugins by copying the
+    # single-source bundle artifact dsh-argo-workspace/index.js. It connects
+    # directly to the argo MCP server (no dsh-mcp-client row needed) with a
+    # zero-dependency minimal MCP stdio client, registers every tool as
     # mcp__argo__* and injects the current session's workspace directory
     # (SessionHeader.cwd) as the per-call `workspaceRoot`, so ONE dsh instance
     # follows whichever workspace the user switched to - no model-visible
-    # parameters, no internal tool names, no restart. The argo server honors
-    # the injected workspaceRoot unconditionally.
+    # parameters, no internal tool names, no restart. Copying (not embedding a
+    # template) keeps the deployed plugin and the shipped bundle identical.
     param(
         [string]$DshHome
     )
+    $source = Join-Path (Join-Path $repoRoot 'dsh-argo-workspace') 'index.js'
+    if (-not (Test-Path $source)) {
+        Write-Warning "  $source not found; DSH workspace bridge skipped."
+        return $null
+    }
     $dir = Join-Path (Join-Path $DshHome 'plugins') 'dsh-argo-workspace'
     New-Item -ItemType Directory -Force -Path $dir | Out-Null
-    $plugin = @'
-// dsh-argo-workspace - generated by install-argo.ps1 (single source of truth:
-// the installer; this file is a deployment artifact, do not edit by hand).
-//
-// Direct MCP bridge to the argo server for DeepSeek Harness. Registers every
-// argo tool as mcp__argo__* and injects the current session's workspace
-// directory (SessionHeader.cwd) as the per-call `workspaceRoot` argument, so
-// one dsh instance follows whichever workspace the user switched to - the
-// model sees no extra parameters and no internal tool names. The argo server
-// honors the injected workspaceRoot unconditionally.
-//
-// Zero dependencies on purpose: implements the minimal MCP stdio client
-// (JSON-RPC 2.0, one JSON object per line) with Node built-ins only, so the
-// plugin runs from any DSH layout without resolving @modelcontextprotocol/sdk.
-import { spawn } from 'node:child_process'
-import readline from 'node:readline'
-
-export const name = 'dsh-argo-workspace'
-export const inject = ['tools']
-
-/** Minimal MCP stdio client over the argo server process. */
-function createArgoClient(serverPath, env, cwd) {
-  const child = spawn('node', [serverPath], {
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env,
-    ...(cwd ? { cwd } : {}),
-  })
-  const pending = new Map()
-  let nextId = 1
-  readline.createInterface({ input: child.stdout }).on('line', (line) => {
-    let message
-    try { message = JSON.parse(line) } catch { return }
-    if (message && typeof message.id === 'number' && pending.has(message.id)) {
-      const { resolve, reject } = pending.get(message.id)
-      pending.delete(message.id)
-      if (message.error) reject(new Error(JSON.stringify(message.error)))
-      else resolve(message.result)
-    }
-  })
-  child.stderr.on('data', () => {}) // drain; the argo server logs to stderr
-  const request = (method, params) => new Promise((resolve, reject) => {
-    const id = nextId++
-    pending.set(id, { resolve, reject })
-    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n')
-  })
-  return {
-    request,
-    notify: (method, params) => {
-      child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n')
-    },
-    close: () => child.kill(),
-  }
-}
-
-/** Connect, list tools, register them, and keep the client until disposal. */
-export async function apply(ctx, config) {
-  const serverPath = config.serverPath
-  const workspaces = Array.isArray(config.workspaces) ? config.workspaces : []
-  const env = { ...process.env }
-  if (workspaces.length > 0) env.ARGO_WORKSPACE_ROOTS = workspaces.join(';')
-  const client = createArgoClient(serverPath, env, config.cwd)
-  ctx.effect(() => () => client.close(), 'dsh-argo-workspace.dispose()')
-
-  let tools = []
-  try {
-    await client.request('initialize', {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'dsh-argo-workspace', version: '0.1.0' },
-    })
-    client.notify('notifications/initialized', {})
-    const listed = await client.request('tools/list', {})
-    tools = (listed && Array.isArray(listed.tools)) ? listed.tools : []
-  } catch (error) {
-    console.warn(`[dsh-argo-workspace] failed to connect to the argo MCP server (${serverPath}): ${error && error.message ? error.message : error}`)
-    return
-  }
-
-  const disposers = []
-  for (const tool of tools) {
-    const publicName = 'mcp__argo__' + tool.name
-    disposers.push(ctx.tools.register({
-      name: publicName,
-      description: tool.description ?? '',
-      parameters: tool.inputSchema,
-      output: {
-        schema: {
-          type: 'object',
-          properties: {
-            content: { type: 'array', items: {} },
-            structuredContent: {},
-          },
-          required: ['content'],
-          additionalProperties: false,
-        },
-        render: (_args, value) => value.content,
-      },
-      execute: async (args, exec) => {
-        // SessionHeader.cwd (the durable session workspace), NOT
-        // requestHeader() — that returns the request EpochHeader
-        // (config/system/tools) which has no cwd field.
-        const sessionCwd = exec && exec.agent && exec.agent.session
-          ? exec.agent.session.header?.cwd
-          : undefined
-        const injected = { ...(args && typeof args === 'object' ? args : {}) }
-        if (typeof sessionCwd === 'string' && sessionCwd !== '') {
-          injected.workspaceRoot = sessionCwd
-        }
-        if (exec && exec.signal && exec.signal.aborted) {
-          throw new Error('aborted')
-        }
-        const result = await client.request('tools/call', {
-          name: tool.name,
-          arguments: injected,
-        })
-        const text = Array.isArray(result.content)
-          ? result.content
-              .map((block) => block && block.type === 'text' && typeof block.text === 'string'
-                ? block.text
-                : JSON.stringify(block))
-              .join('\n')
-          : (result.toolResult !== undefined ? JSON.stringify(result.toolResult) : '(no output)')
-        if (result.isError === true) throw new Error(text)
-        return {
-          content: [{ type: 'text', text }],
-          ...(result.structuredContent !== undefined ? { structuredContent: result.structuredContent } : {}),
-        }
-      },
-    }))
-  }
-  ctx.effect(() => () => {
-    for (const dispose of disposers) dispose()
-  }, 'dsh-argo-workspace.tools')
-}
-'@
     $indexPath = Join-Path $dir 'index.js'
-    [System.IO.File]::WriteAllText($indexPath, $plugin, (New-Object System.Text.UTF8Encoding $false))
-    Write-Host "  DSH workspace bridge generated -> $indexPath"
+    Copy-Item -Force -Path $source -Destination $indexPath
+    Write-Host "  DSH workspace bridge <- $source (single source)"
     return $indexPath
 }
 
@@ -867,8 +854,8 @@ if ($SkipDsh) {
     Write-Host '  argo\skills\agent-search-diagnosis -> $DshHome\skills\agent-search-diagnosis (DeepSeek Harness skill)'
     Copy-Tree -Source $diagSkillSrc -Destination (Join-Path (Join-Path $DshHome 'skills') 'agent-search-diagnosis')
 
-    Write-Host "[17/22] argo\rules\<WakeupGuideline> -> $DshHome\plugins\dsh-argo-wakeup\index.js (DeepSeek Harness wakeup plugin)"
-    $wakeupDshPath = New-DshWakeupPlugin -DshHome $DshHome -RuleText $ruleSrcContent
+    Write-Host "[17/22] dsh-argo-wakeup\index.js (single source; gate from argo\rules\archgraph.instructions.md <WakeupGuideline>) -> $DshHome\plugins\dsh-argo-wakeup\index.js (DeepSeek Harness wakeup plugin)"
+    $wakeupDshPath = New-DshWakeupPlugin -DshHome $DshHome
 
     Write-Host "[18/22] argo-workspace + argo-wakeup rows -> $patchPath (DeepSeek Harness MCP bridge + wakeup plugin)"
     # The generated dsh-argo-workspace bridge connects directly to the argo
@@ -937,6 +924,48 @@ Copy-Tree -Source $diagSkillSrc -Destination (Join-Path (Join-Path $OpenClawHome
     Write-Host '  the OpenClaw gateway (openclaw gateway restart) if it is already running.'
 }
 
+if ($SkipDoubao) {
+    Write-Host 'Skipped Doubao integration (-SkipDoubao).'
+} else {
+    # Doubao (desktop agent mode) skill discovery. Doubao adopts the Anthropic
+    # Agent Skills spec and loads user skills from
+    #   <workspace>/.user_skills/<name>/SKILL.md  (per-session workspace root)
+    # plus a global user root
+    #   ~/Doubao/skills/<name>/SKILL.md
+    # Doubao exposes no AGENTS.md-equivalent always-on instruction file, so the
+    # WakeupGuideline / unconditional startup gate has no hook (skills are the
+    # fully ported surface). MCP servers are registered through Doubao's in-app
+    # custom connector UI (STDIO), not a config file, so the installer emits a
+    # copy-paste connector recipe instead of writing a config.
+    $doubaoSkills = @('argo-init', 'ea-human-reconcile', 'agent-search-diagnosis')
+    $doubaoSkillsSrc = Join-Path $argoDir 'skills'
+    Write-Host '==> Deploying Doubao (desktop agent mode) integration'
+    Copy-DoubaoSkills -Root (Join-Path $DoubaoWorkspace '.user_skills') -SourceSkillsRoot $doubaoSkillsSrc -SkillNames $doubaoSkills -Label 'workspace .user_skills'
+    Copy-DoubaoSkills -Root (Join-Path $DoubaoHome 'skills') -SourceSkillsRoot $doubaoSkillsSrc -SkillNames $doubaoSkills -Label 'global ~/Doubao/skills'
+    # Entry skill: the single-source ARGO rules packaged as a Doubao skill whose
+    # always-in-context description states the STEP 0 gate and the mandate to
+    # load it before any intent-graph read/write. This is the closest Doubao
+    # allows to an always-on rule (skills have no system-prompt hook).
+    $doubaoRule = Join-Path $argoDir 'rules\archgraph.instructions.md'
+    foreach ($doubaoRoot in @((Join-Path $DoubaoWorkspace '.user_skills'), (Join-Path $DoubaoHome 'skills'))) {
+        $entryDir = Join-Path $doubaoRoot 'archgraph-argo'
+        New-Item -ItemType Directory -Force -Path $entryDir | Out-Null
+        Convert-RuleToSkill -RuleFile $doubaoRule -DestinationFile (Join-Path $entryDir 'SKILL.md')
+        Write-Host "  entry skill (ARGO rules) -> $(Join-Path $entryDir 'SKILL.md')"
+    }
+    Write-Host '  Doubao injects each skill''s name + description into context and loads the'
+    Write-Host '  body on trigger; new skills are picked up on the next agent session.'
+    $doubaoBridgeDir = Join-Path $ArgoRoot 'mcp-bridges'
+    Copy-Tree -Source (Join-Path $argoDir 'mcp-bridges') -Destination $doubaoBridgeDir
+    $doubaoBridgePath = Join-Path $doubaoBridgeDir 'graph-mcp-stdio.js'
+    if (-not (Test-Path $doubaoBridgePath)) { $doubaoBridgePath = '' }
+    Write-DoubaoMcpRecipe -RecipePath (Join-Path $ArgoRoot 'doubao-mcp.json') -ArgoServer (Join-Path $ArgoRoot 'scripts\argo-mcp-server.js') -BridgePath $doubaoBridgePath -GraphMcpUrl $GraphMcpUrl
+    Write-Host '  the argo connector has no fixed workspace: it follows the workspace you'
+    Write-Host '  select in Doubao (MCP roots / connector workingDirectory), like OpenCode/DSH.'
+    Write-Host '  note: Doubao has no AGENTS.md-equivalent always-on rule file, so the ARGO'
+    Write-Host '  WakeupGuideline / unconditional startup gate is not deployed (no hook).'
+}
+
 if ($SkipDeps) {
     Write-Host 'Skipped dependency install (-SkipDeps).'
 } elseif (Get-Command npm -ErrorAction SilentlyContinue) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {
@@ -45,7 +45,10 @@
     "playwright": "1.61.1"
   },
   "scripts": {
-    "test": "node --test \"tests/*.test.js\""
+    "test": "node --test \"tests/*.test.js\"",
+    "acceptance": "node scripts/mcp-acceptance.js",
+    "gen:dsh-plugins": "node scripts/gen-dsh-plugins.js",
+    "prepack": "node scripts/gen-dsh-plugins.js"
   },
   "engines": {
     "node": ">=18"