archgraph-argo 0.26.2 → 0.28.0

package/install-argo.ps1

@@ -25,6 +25,12 @@ 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]$CodexHome = "$env:USERPROFILE\.codex",
+    [string]$CodexRepoRoot = '',
+    [switch]$SkipCodex,
     [string]$McpPath,
     [string]$GraphMcpUrl = 'https://argo.derekworkspacev5.com/mcp'
 )
@@ -298,16 +304,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 +368,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
@@ -460,6 +599,71 @@ function Write-OpenClawMcpConfig {
     [System.IO.File]::WriteAllText($configPath, $json, (New-Object System.Text.UTF8Encoding $false))
 }
 
+function ConvertTo-TomlString {
+    # Encode a value as a TOML basic string (escape backslash + double quote).
+    param([string]$Value)
+    return '"' + ($Value -replace '\\', '\\\\' -replace '"', '\"') + '"'
+}
+
+function Write-CodexMcpConfig {
+    # Register the argo and graph-mcp MCP servers in the Codex config file
+    # (~/.codex/config.toml). Codex stores MCP servers as standard TOML tables
+    # [mcp_servers.<name>] (NOT the JSON/YAML shapes the other hosts use), so
+    # this is a text-level table upsert:
+    #   - the previous managed tables ([mcp_servers.argo], [mcp_servers.argo.env],
+    #     [mcp_servers.graph-mcp]) are removed first, so a re-deploy replaces
+    #     rather than duplicates them (duplicate TOML tables are a parse error);
+    #   - every unrelated config.toml key (the desktop app's own settings, other
+    #     MCP servers, plugins, marketplaces) is preserved verbatim;
+    #   - the file is written without a BOM.
+    #
+    # Workspace: Codex spawns every stdio MCP server with the SESSION workspace
+    # as its process cwd and without ARGO_* env (verified), and argo-paths.js
+    # falls back to process.cwd() when ARGO_REPO_ROOT is unset. So, like
+    # OpenCode / DeepSeek Harness, the single global argo server FOLLOWS whichever
+    # workspace the user opened in Codex and ARGO_REPO_ROOT is NOT pinned by
+    # default. Pass -RepoRoot to pin a fixed workspace instead (opt-in).
+    param(
+        [string]$ConfigPath,
+        [string]$ArgoServer,
+        [string]$GraphMcpUrl,
+        [string]$RepoRoot
+    )
+    $targetHeaders = @('[mcp_servers.argo]', '[mcp_servers.argo.env]', '[mcp_servers.graph-mcp]')
+    $existing = if (Test-Path $ConfigPath) { [System.IO.File]::ReadAllText($ConfigPath) } else { '' }
+    $lines = if ($existing -eq '') { @() } else { $existing -split "\r?\n" }
+
+    $kept = New-Object System.Collections.Generic.List[string]
+    $i = 0
+    while ($i -lt $lines.Count) {
+        $trim = $lines[$i].Trim()
+        if ($targetHeaders -contains $trim) {
+            # Skip the header and its body up to the next top-level table header.
+            $i++
+            while ($i -lt $lines.Count -and -not $lines[$i].TrimStart().StartsWith('[')) { $i++ }
+            continue
+        }
+        $kept.Add($lines[$i])
+        $i++
+    }
+    while ($kept.Count -gt 0 -and $kept[$kept.Count - 1].Trim() -eq '') { $kept.RemoveAt($kept.Count - 1) }
+
+    $blocks = New-Object System.Collections.Generic.List[string]
+    $blocks.Add((@('[mcp_servers.argo]', 'command = "node"', "args = [$(ConvertTo-TomlString $ArgoServer)]") -join "`n"))
+    if (-not [string]::IsNullOrWhiteSpace($RepoRoot)) {
+        $blocks.Add(("[mcp_servers.argo.env]`nARGO_REPO_ROOT = $(ConvertTo-TomlString $RepoRoot)"))
+    }
+    $blocks.Add(("[mcp_servers.graph-mcp]`nurl = $(ConvertTo-TomlString $GraphMcpUrl)"))
+
+    $result = ($kept -join "`n")
+    if ($result.Trim() -ne '') { $result = $result.TrimEnd() + "`n`n" }
+    $result += ($blocks -join "`n`n") + "`n"
+
+    New-Item -ItemType Directory -Force -Path (Split-Path $ConfigPath) | Out-Null
+    [System.IO.File]::WriteAllText($ConfigPath, $result, (New-Object System.Text.UTF8Encoding $false))
+    Write-Host "  Codex MCP: argo (stdio) + graph-mcp (streamable http) -> $ConfigPath"
+}
+
 function Write-DshManagedBlock {
     # Text-level upsert of a marker-delimited block into a file (used for the
     # managed rows in ~/.dsh/cordis.patch.yml): replaces the previous managed
@@ -491,200 +695,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
 }
 
@@ -789,10 +844,9 @@ Write-Host "[4/22] argo\skills\argo-init -> $skillDest"
 Copy-Tree -Source $skillSrc -Destination $skillDest
 $reconcileSkillSrc = Join-Path (Join-Path $argoDir 'skills') 'ea-human-reconcile'
 $diagSkillSrc = Join-Path (Join-Path $argoDir 'skills') 'agent-search-diagnosis'
-Write-Host '  argo\skills\ea-human-reconcile -> $SkillsRoot\ea-human-reconcile (EA human draft reconcile skill)'
+Write-Host "  argo\skills\ea-human-reconcile -> $SkillsRoot\ea-human-reconcile (EA human draft reconcile skill)"
 Copy-Tree -Source $reconcileSkillSrc -Destination (Join-Path $SkillsRoot 'ea-human-reconcile')
-Write-Host '  argo\skills\agent-search-diagnosis -> $SkillsRoot\agent-search-diagnosis (agent search diagnosis skill)'
-Copy-Tree -Source $diagSkillSrc -Destination (Join-Path $SkillsRoot 'agent-search-diagnosis')
+# agent-search-diagnosis is OpenCode-only (it assumes `opencode` session export); not deployed to Copilot.
 
 $ruleSrc = Join-Path (Join-Path $argoDir 'rules') 'archgraph.instructions.md'
 $ruleDest = Join-Path $PromptsRoot 'archgraph.instructions.md'
@@ -808,10 +862,9 @@ Copy-Item -Force -Path $depsSrc -Destination $depsDest
 $cursorSkillDest = Join-Path $CursorSkillsRoot 'argo-init'
 Write-Host "[7/22] argo\skills\argo-init -> $cursorSkillDest (Cursor)"
 Copy-Tree -Source $skillSrc -Destination $cursorSkillDest
-Write-Host '  argo\skills\ea-human-reconcile -> $CursorSkillsRoot\ea-human-reconcile (Cursor)'
+Write-Host "  argo\skills\ea-human-reconcile -> $CursorSkillsRoot\ea-human-reconcile (Cursor)"
 Copy-Tree -Source $reconcileSkillSrc -Destination (Join-Path $CursorSkillsRoot 'ea-human-reconcile')
-Write-Host '  argo\skills\agent-search-diagnosis -> $CursorSkillsRoot\agent-search-diagnosis (Cursor)'
-Copy-Tree -Source $diagSkillSrc -Destination (Join-Path $CursorSkillsRoot 'agent-search-diagnosis')
+# agent-search-diagnosis is OpenCode-only (it assumes `opencode` session export); not deployed to Cursor.
 
 $mcpBridgeSrc = Join-Path $argoDir 'mcp-bridges'
 $mcpBridgeDest = Join-Path $CursorMcpBridgesRoot ''
@@ -821,9 +874,9 @@ Copy-Tree -Source $mcpBridgeSrc -Destination $mcpBridgeDest
 $openCodeSkillDest = Join-Path $OpenCodeSkillsRoot 'argo-init'
 Write-Host "[8/22] argo\skills\argo-init -> $openCodeSkillDest (OpenCode)"
 Copy-Tree -Source $skillSrc -Destination $openCodeSkillDest
-Write-Host '  argo\skills\ea-human-reconcile -> $OpenCodeSkillsRoot\ea-human-reconcile (OpenCode)'
+Write-Host "  argo\skills\ea-human-reconcile -> $OpenCodeSkillsRoot\ea-human-reconcile (OpenCode)"
 Copy-Tree -Source $reconcileSkillSrc -Destination (Join-Path $OpenCodeSkillsRoot 'ea-human-reconcile')
-Write-Host '  argo\skills\agent-search-diagnosis -> $OpenCodeSkillsRoot\agent-search-diagnosis (OpenCode)'
+Write-Host "  argo\skills\agent-search-diagnosis -> $OpenCodeSkillsRoot\agent-search-diagnosis (OpenCode-only: assumes opencode session export)"
 Copy-Tree -Source $diagSkillSrc -Destination (Join-Path $OpenCodeSkillsRoot 'agent-search-diagnosis')
 
 Write-Host "[9/22] argo\rules\archgraph.instructions.md -> $OpenCodeAgentsPath (OpenCode global AGENTS.md)"
@@ -862,15 +915,14 @@ if ($SkipDsh) {
 
     Write-Host "[16/22] argo\skills\argo-init -> $dshSkillDest (DeepSeek Harness skill)"
     Copy-Tree -Source (Join-Path $argoDir 'skills\argo-init') -Destination $dshSkillDest
-    Write-Host '  argo\skills\ea-human-reconcile -> $DshHome\skills\ea-human-reconcile (DeepSeek Harness skill)'
+    Write-Host "  argo\skills\ea-human-reconcile -> $DshHome\skills\ea-human-reconcile (DeepSeek Harness skill)"
     Copy-Tree -Source (Join-Path $argoDir 'skills\ea-human-reconcile') -Destination (Join-Path (Join-Path $DshHome 'skills') 'ea-human-reconcile')
-    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')
+    # agent-search-diagnosis is OpenCode-only (it assumes `opencode` session export); not deployed to DeepSeek Harness.
 
-    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)"
+    Write-Host "[18/22] argo-workspace (argo + graph-mcp) + argo-wakeup rows -> $patchPath (DeepSeek Harness MCP bridges + wakeup plugin)"
     # The generated dsh-argo-workspace bridge connects directly to the argo
     # server (no dsh-mcp-client row), registers every tool as mcp__argo__* and
     # injects the current session's workspace (SessionHeader.cwd) as the
@@ -878,9 +930,20 @@ if ($SkipDsh) {
     # user switched to. The server honors the injected workspaceRoot
     # unconditionally.
     $bridgeDshPath = New-DshWorkspaceBridge -DshHome $DshHome
+    # Deploy the federation Graph MCP stdio bridge next to the DSH plugins, so the
+    # remote graph-mcp (registry_*/mirror_*/graph_*) mounts as an ordinary local
+    # stdio server - the same bridge Cursor/Doubao already use.
+    $dshBridgeDir = Join-Path $DshHome 'mcp-bridges'
+    Copy-Tree -Source (Join-Path $argoDir 'mcp-bridges') -Destination $dshBridgeDir
+    $dshGraphBridgePath = (Join-Path $dshBridgeDir 'graph-mcp-stdio.js').Replace('\', '/')
     if ($bridgeDshPath) {
         $bridgeUrl = 'file:///' + (($bridgeDshPath -replace '\\', '/').TrimStart('/'))
-        $bridgeConfig = "    config:`n      serverPath: '$argoServer'`n"
+        # One bridge plugin mounts every server; the argo server follows the session
+        # workspace (workspaceRoot), graph-mcp does not inject workspaceRoot.
+        $serversYaml = "      servers:`n"
+        $serversYaml += "        - id: argo`n          serverPath: '$argoServer'`n          injectWorkspaceRoot: true`n"
+        $serversYaml += "        - id: graph-mcp`n          command: node`n          args:`n            - '$dshGraphBridgePath'`n          env:`n            GRAPH_MCP_URL: '$GraphMcpUrl'`n          injectWorkspaceRoot: false`n"
+        $bridgeConfig = "    config:`n" + $serversYaml
         if ($DshWorkspaces) {
             $wsList = @($DshWorkspaces.Replace('\', '/').Split(';') | ForEach-Object { "        - $_" }) -join "`n"
             $bridgeConfig += "      workspaces:`n" + $wsList + "`n"
@@ -904,10 +967,8 @@ if ($SkipDsh) {
     Write-Host "[19/22] argo\agents -> $DshHome\.agent-presets\<id> (DeepSeek Harness agent presets)"
     New-DshAgentPresets -DshHome $DshHome -AgentsSrc (Join-Path $argoDir 'agents')
 
-    Write-Host "  note: graph-mcp remote ($GraphMcpUrl) is NOT registered for DeepSeek Harness -"
-    Write-Host "  ~/.dsh/cordis.patch.yml only carries plugin rows (the dsh-argo-workspace bridge spawns"
-    Write-Host "  the local argo server); an HTTP remote MCP server has no equivalent cordis row here."
-    Write-Host "  Restart `dsh web` to activate the MCP bridge and the wakeup plugin;"
+    Write-Host "  graph-mcp registered for DeepSeek Harness as a stdio bridge -> $dshGraphBridgePath (GRAPH_MCP_URL=$GraphMcpUrl)"
+    Write-Host "  Restart `dsh web` to activate the MCP bridges and the wakeup plugin;"
     Write-Host '  new sessions pick up the global rule and the argo-init skill automatically.'
     Write-Host '  The argo tools (mcp__argo__*) auto-follow the workspace the user switched to'
     Write-Host '  in one dsh instance - no restart needed between workspaces (the server honors'
@@ -927,16 +988,58 @@ if ($SkipOpenClaw) {
 
     Write-Host "[21/22] argo\skills\argo-init -> $openClawSkillDest (OpenClaw managed skill, all agents)"
     Copy-Tree -Source (Join-Path $argoDir 'skills\argo-init') -Destination $openClawSkillDest
-Write-Host '  argo\skills\ea-human-reconcile -> $OpenClawHome\skills\ea-human-reconcile (OpenClaw managed skill, all agents)'
+Write-Host "  argo\skills\ea-human-reconcile -> $OpenClawHome\skills\ea-human-reconcile (OpenClaw managed skill, all agents)"
 Copy-Tree -Source (Join-Path $argoDir 'skills\ea-human-reconcile') -Destination (Join-Path (Join-Path $OpenClawHome 'skills') 'ea-human-reconcile')
-Write-Host '  argo\skills\agent-search-diagnosis -> $OpenClawHome\skills\agent-search-diagnosis (OpenClaw managed skill, all agents)'
-Copy-Tree -Source $diagSkillSrc -Destination (Join-Path (Join-Path $OpenClawHome 'skills') 'agent-search-diagnosis')
+# agent-search-diagnosis is OpenCode-only (it assumes `opencode` session export); not deployed to OpenClaw.
 
     Write-Host '  OpenClaw injects AGENTS.md into Project Context on every session, so the wakeup'
     Write-Host '  gate (UNCONDITIONAL STARTUP GATE) is active on the next OpenClaw session; restart'
     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.
+    # agent-search-diagnosis is OpenCode-only (it assumes `opencode` session export); not deployed to Doubao.
+    $doubaoSkills = @('argo-init', 'ea-human-reconcile')
+    $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) {
@@ -1113,6 +1216,33 @@ if ($SkipMcp) {
     }
 }
 
+if ($SkipCodex) {
+    Write-Host 'Skipped Codex integration (-SkipCodex).'
+} else {
+    $ruleSrcContent = Get-Content $ruleSrc -Raw -Encoding UTF8
+    $codexAgentsPath = Join-Path $CodexHome 'AGENTS.md'
+    $codexSkillsRoot = Join-Path $CodexHome 'skills'
+
+    Write-Host '==> Deploying Codex integration'
+    Write-Host "[Codex 1/3] argo\rules\archgraph.instructions.md -> $codexAgentsPath (Codex global AGENTS.md, frontmatter stripped)"
+    Write-ArchGraphRuleBlock -DestPath $codexAgentsPath -RuleText $ruleSrcContent -Label 'Codex rule'
+
+    Write-Host "[Codex 2/3] argo\skills -> $codexSkillsRoot (Codex user skills: argo-init, ea-human-reconcile)"
+    Copy-DoubaoSkills -Root $codexSkillsRoot -SourceSkillsRoot (Join-Path $argoDir 'skills') -SkillNames @('argo-init', 'ea-human-reconcile') -Label 'Codex user skills'
+    # agent-search-diagnosis is OpenCode-only (it assumes `opencode` session export); not deployed to Codex.
+
+    if ($SkipMcp) {
+        Write-Host '  Skipped Codex MCP registration (-SkipMcp).'
+    } else {
+        $codexConfigPath = Join-Path $CodexHome 'config.toml'
+        Write-Host "[Codex 3/3] argo MCP (stdio) + graph-mcp -> $codexConfigPath (Codex config.toml)"
+        Write-CodexMcpConfig -ConfigPath $codexConfigPath -ArgoServer $argoServer -GraphMcpUrl $GraphMcpUrl -RepoRoot $CodexRepoRoot
+    }
+    Write-Host '  Codex injects the global AGENTS.md into every session, so the wakeup gate is'
+    Write-Host '  active on the next Codex session; skills load on trigger. Restart Codex so it'
+    Write-Host '  picks up config.toml and the new skills.'
+}
+
 $wakeupPluginPath = Join-Path $PluginsRoot 'argo-wakeup.js'
 if (Test-Path $wakeupPluginPath) {
     Write-Host '==> Registering argo-wakeup plugin in OpenCode'