@mawaru/sdk 0.11.0 → 0.14.1

package/_schemas/ai-manifest.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest"
 import { AI_MODELS, aiManifestSchema } from "./ai-manifest.js"
-import { envelopeSchemaOf, instructionSchema } from "./port-spec.js"
+import { instructionSchema } from "./port-spec.js"
 
-const envelope = envelopeSchemaOf({ type: "string" })
+const textOutput = { type: "string" }
 
 const valid = {
   name: "返信下書き",
@@ -11,8 +11,8 @@ const valid = {
   model: "claude-opus-4-8",
   skills: ["answer-faq"],
   env: ["ANTHROPIC_API_KEY"],
-  inputs: { in: {} },
-  outputs: { main: envelope },
+  inputs: { in: { schema: {} } },
+  outputs: { main: textOutput },
 }
 
 describe("aiManifestSchema", () => {
@@ -28,8 +28,8 @@ describe("aiManifestSchema", () => {
   it("name / description / model / skills / env は省略できる（既定値が補われる）", () => {
     const manifest = aiManifestSchema.parse({
       prompt: valid.prompt,
-      inputs: { in: {} },
-      outputs: { main: envelope },
+      inputs: { in: { schema: {} } },
+      outputs: { main: textOutput },
     })
     expect(manifest.name).toBeUndefined()
     expect(manifest.model).toBe("claude-opus-5")
@@ -56,90 +56,85 @@ describe("aiManifestSchema", () => {
     ).toThrow()
   })
 
-  it('inputs は "in" 必須・instruction は任意（kind が固定する2口）', () => {
-    // in は必須
+  it("inputs は key 自由・1件以上（in / instruction の固定構成は廃止）", () => {
+    // 0件は拒否
     expect(() => aiManifestSchema.parse({ ...valid, inputs: {} })).toThrow()
+    // key は自由（旧固定の in / instruction 以外も宣言できる）
     expect(() =>
-      aiManifestSchema.parse({ ...valid, inputs: { data: {} } }),
-    ).toThrow()
-    // 固定ポートの instruction も宣言に載る（ノードの現在の姿を書き出すため）
-    expect(
       aiManifestSchema.parse({
         ...valid,
-        inputs: { in: {}, instruction: instructionSchema() },
-      }).inputs.instruction,
-    ).toEqual(instructionSchema())
-    // in を2口に分ける前に同期された config.json（in だけ）もそのまま読める
+        inputs: { task: { schema: {} }, feedback: { schema: {} } },
+      }),
+    ).not.toThrow()
+    // key はポート key の規則（英小文字始まり・英数字と _）
+    for (const key of ["Bad", "1st", "a-b", ""]) {
+      expect(() =>
+        aiManifestSchema.parse({ ...valid, inputs: { [key]: { schema: {} } } }),
+      ).toThrow()
+    }
+  })
+
+  it("inputs は { schema, resume } の新形式で宣言でき、resume が読める", () => {
+    const parsed = aiManifestSchema.parse({
+      ...valid,
+      inputs: {
+        in: { schema: { type: "object" } },
+        instruction: { schema: instructionSchema(), resume: true },
+      },
+    })
+    expect(parsed.inputs.in).toEqual({ schema: { type: "object" } })
+    expect(parsed.inputs.instruction?.schema).toEqual(instructionSchema())
+    expect(parsed.inputs.instruction?.resume).toBe(true)
+  })
+
+  it("旧形式（値が素の JSON Schema）は { schema: 値 } として読める", () => {
+    const legacy = aiManifestSchema.parse({
+      ...valid,
+      inputs: { in: { type: "object" }, instruction: instructionSchema() },
+    })
+    expect(legacy.inputs.in).toEqual({ schema: { type: "object" } })
+    expect(legacy.inputs.instruction).toEqual({
+      schema: instructionSchema(),
+    })
+    // 未宣言 {} も旧形式として { schema: {} } になる
     expect(
-      Object.keys(
-        aiManifestSchema.parse({ ...valid, inputs: { in: {} } }).inputs,
-      ),
-    ).toEqual(["in"])
-    // kind が固定しない key は宣言できない
-    expect(() =>
-      aiManifestSchema.parse({ ...valid, inputs: { in: {}, extra: {} } }),
-    ).toThrow()
+      aiManifestSchema.parse({ ...valid, inputs: { in: {} } }).inputs.in,
+    ).toEqual({ schema: {} })
   })
 
   it("outputs は1件以上・key 自由（AI の複数出口＝分岐）", () => {
     expect(() => aiManifestSchema.parse({ ...valid, outputs: {} })).toThrow()
     expect(() =>
-      aiManifestSchema.parse({ ...valid, outputs: { draft: envelope } }),
+      aiManifestSchema.parse({ ...valid, outputs: { reply: textOutput } }),
     ).not.toThrow()
     expect(() =>
       aiManifestSchema.parse({
         ...valid,
-        outputs: { spam: envelope, sales: envelope, support: envelope },
+        outputs: { spam: textOutput, sales: textOutput, support: textOutput },
       }),
     ).not.toThrow()
   })
 
-  it("outputs は全出口に封筒型 { data, description } を強制する（data は任意の型）", () => {
+  it("outputs は任意の JSON Schema を受け付ける（形の強制はしない）", () => {
     for (const schema of [
       {}, // any
       { type: "string" },
-      { type: "object", properties: { text: { type: "string" } } }, // data キーなし
-      {
-        type: "object",
-        properties: { data: { type: "string" } }, // description なし
-        required: ["data"],
-      },
+      { type: "object", properties: { text: { type: "string" } } },
+      { type: "array", items: { type: "number" } },
       {
+        // かつて強制していた { data, description } もただの object として valid
         type: "object",
         properties: {
           data: { type: "string" },
-          description: { type: "string" }, // description が optional
+          description: { type: "string" },
         },
-        required: ["data"],
+        required: ["data", "description"],
       },
     ]) {
       expect(() =>
         aiManifestSchema.parse({ ...valid, outputs: { main: schema } }),
-      ).toThrow()
-      // 妥当な出口に混ざっていても、封筒型でない出口があれば弾く
-      expect(() =>
-        aiManifestSchema.parse({
-          ...valid,
-          outputs: { main: envelope, other: schema },
-        }),
-      ).toThrow()
+      ).not.toThrow()
     }
-    // data が任意の構造（カタログ外の object）でも通る
-    expect(() =>
-      aiManifestSchema.parse({
-        ...valid,
-        outputs: {
-          main: envelopeSchemaOf({
-            type: "object",
-            properties: {
-              title: { type: "string" },
-              count: { type: "number" },
-            },
-            required: ["title"],
-          }),
-        },
-      }),
-    ).not.toThrow()
   })
 
   it("ディレクトリ名として不正な skill 名を拒否する", () => {

package/_schemas/ai-manifest.ts

@@ -1,6 +1,5 @@
 import { z } from "zod"
-import { jsonSchemaSchema } from "./node.js"
-import { isAiEnvelopeSchema, manifestInKeysViolation } from "./port-spec.js"
+import { jsonSchemaSchema, PORT_KEY_PATTERN } from "./node.js"
 
 // AI ノードのモデル選択肢（既定は Opus：下書き品質が価値の中心。費用はユーザー持ち）。
 // エイリアス（"opus" 等）は採らずバージョンを固定する：実行のたびに黙って別モデルへ
@@ -15,6 +14,23 @@ export const aiModelSchema = z.enum(AI_MODELS)
 export type AiModel = z.infer<typeof aiModelSchema>
 export const DEFAULT_AI_MODEL = "claude-opus-5" satisfies AiModel
 
+// 入力口の宣言：スキーマ＋実行属性。resume: true の口から入力が届いた実行は
+// 同じノードの直近セッションを復元して再開する（backend が ports.resume へ同期して
+// payload 発行時に参照する。ポート型固定の撤去とセッション再開のポート属性化.md）
+export const aiInputDeclSchema = z.object({
+  schema: jsonSchemaSchema,
+  resume: z.boolean().optional(),
+})
+export type AiInputDecl = z.infer<typeof aiInputDeclSchema>
+
+// 旧形式（値が素の JSON Schema）は { schema: 値 } として読む。判別は「schema キーを
+// 持つか」：JSON Schema のトップレベルに "schema" キーは現れない（メタスキーマ参照は
+// "$schema"）ので実用上一意。書き戻し（backend の syncNodeConfigs）は常に新形式で書く
+const aiInputValueSchema = z.union([
+  aiInputDeclSchema,
+  jsonSchemaSchema.transform((schema): AiInputDecl => ({ schema })),
+])
+
 // nodes/ai/<dir>/config.json（実行repoの構造見直し）。AI ノードの定義（prompt/model/skills/
 // 入出力スキーマ/env）は repo 側が正で、エディタが取り込んで ports を自動生成する
 // （実行時の正は ports テーブルのまま。プログラム規約 v2 と同じ関係）。
@@ -42,38 +58,37 @@ export const aiManifestSchema = z
     // 実行中の経過（発話・ツール呼び出し）を Actions ログへ逐次出すデバッグフラグ。
     // 通常時は config.json にキーを書かない（インスペクタも false ならキーを消す）
     verbose: z.boolean().optional(),
-    inputs: z.record(z.string(), jsonSchemaSchema),
+    inputs: z.record(z.string(), aiInputValueSchema),
     outputs: z.record(z.string(), jsonSchemaSchema),
   })
   .superRefine((manifest, ctx) => {
-    // in の構成は kind が固定する（ai は上流データの in ＋ 差し戻しの instruction の2口）。
-    // ルールの正は port-spec 側で、ここは参照するだけ
-    const inViolation = manifestInKeysViolation(
-      "ai",
-      Object.keys(manifest.inputs),
-    )
-    if (inViolation) {
-      ctx.addIssue({ code: "custom", path: ["inputs"], message: inViolation })
-    }
-    // outputs は1件以上・key 自由（複数出口＝分岐。AIノードの複数出口（分岐）.md）
-    if (Object.keys(manifest.outputs).length < 1) {
+    // inputs は1件以上・key 自由（in / instruction の固定構成は廃止。
+    // セッション再開は key ではなく resume 属性で決まる）
+    const inKeys = Object.keys(manifest.inputs)
+    if (inKeys.length < 1) {
       ctx.addIssue({
         code: "custom",
-        path: ["outputs"],
-        message: "outputs は1件以上宣言してください",
+        path: ["inputs"],
+        message: "inputs は1件以上宣言してください",
       })
     }
-    // Human 承認 UI が依存する封筒型 { data: T, description: string } を全出口に強制
-    // （どの出口も human に接続できる、という AI ノードの不変条件。saveGraph と同じ判定。
-    // data＝T は任意の JSON Schema）
-    for (const [key, schema] of Object.entries(manifest.outputs)) {
-      if (!isAiEnvelopeSchema(schema)) {
+    for (const key of inKeys) {
+      if (!PORT_KEY_PATTERN.test(key)) {
         ctx.addIssue({
           code: "custom",
-          path: ["outputs", key],
-          message: `outputs.${key} は封筒型 { data, description } で宣言してください（両方必須・description は string）`,
+          path: ["inputs", key],
+          message: `inputs の key が不正です: ${key}（英小文字始まり・英数字と _ のみ）`,
         })
       }
     }
+    // outputs は1件以上・key 自由（複数出口＝分岐。AIノードの複数出口（分岐）.md）。
+    // スキーマは任意の JSON Schema（形の強制はしない）
+    if (Object.keys(manifest.outputs).length < 1) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["outputs"],
+        message: "outputs は1件以上宣言してください",
+      })
+    }
   })
 export type AiManifest = z.infer<typeof aiManifestSchema>

package/_schemas/duplicate-selection.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it } from "vitest"
+import { duplicateSelection } from "./duplicate-selection.js"
+import type { GraphNode } from "./graph.js"
+import { RUN_STARTER } from "./graph.js"
+import type { GraphPort } from "./node.js"
+
+// テスト用の決定的な uuid（extract-component.test.ts と同じ流儀）
+let seq = 0
+const uuid = () => `00000000-0000-4000-8000-${String(++seq).padStart(12, "0")}`
+
+const port = (io: "in" | "out", key: string): GraphPort => ({
+  id: uuid(),
+  io,
+  key,
+  name: key,
+  schema: { type: "object" },
+})
+
+const makeNode = (
+  kind: GraphNode["kind"],
+  name: string,
+  x = 0,
+  y = 0,
+): GraphNode => ({
+  id: uuid(),
+  kind,
+  name,
+  ports: [port("in", "in"), port("out", "main")],
+  hooks: [],
+  position_x: x,
+  position_y: y,
+  ...(kind === "wait"
+    ? { wait: { wait_type: "duration" as const, duration_seconds: 90 } }
+    : {}),
+})
+
+const inOf = (n: GraphNode) => {
+  const p = n.ports.find((p) => p.io === "in")
+  if (!p) throw new Error("in がない")
+  return p
+}
+const outOf = (n: GraphNode, key = "main") => {
+  const p = n.ports.find((p) => p.io === "out" && p.key === key)
+  if (!p) throw new Error("out がない")
+  return p
+}
+const connect = (from: GraphNode, to: GraphNode) => ({
+  from_port_id: outOf(from).id,
+  to_port_id: inOf(to).id,
+})
+
+// 直列 A → B → C → D（B, C を選択するのが基本ケース）
+const chain = () => {
+  const a = makeNode("program", "A", 0, 0)
+  const b = makeNode("wait", "B", 100, 0)
+  const c = makeNode("program", "C", 200, 100)
+  const d = makeNode("program", "D", 300, 0)
+  const nodes = [a, b, c, d]
+  const connections = [connect(a, b), connect(b, c), connect(c, d)]
+  return { a, b, c, d, nodes, connections }
+}
+
+const dup = (
+  nodes: GraphNode[],
+  connections: { from_port_id: string; to_port_id: string }[],
+  selectedIds: string[],
+  dx = 0,
+  dy = 0,
+) =>
+  duplicateSelection({
+    nodes,
+    connections,
+    selectedIds,
+    dx,
+    dy,
+    newId: uuid,
+  })
+
+describe("duplicateSelection（選択ノードの複製）", () => {
+  it("ノード id・ポート id を全て新規に採番する", () => {
+    const { b, c, nodes, connections } = chain()
+    const result = dup(nodes, connections, [b.id, c.id])
+
+    expect(result.nodes).toHaveLength(2)
+    const oldNodeIds = new Set([b.id, c.id])
+    const oldPortIds = new Set([...b.ports, ...c.ports].map((p) => p.id))
+    for (const n of result.nodes) {
+      expect(oldNodeIds.has(n.id)).toBe(false)
+      for (const p of n.ports) expect(oldPortIds.has(p.id)).toBe(false)
+    }
+    // ポート id はグラフ全体で一意（複製内でも重複しない）
+    const newPortIds = result.nodes.flatMap((n) => n.ports.map((p) => p.id))
+    expect(new Set(newPortIds).size).toBe(newPortIds.length)
+  })
+
+  it("元のノード・接続を変更しない", () => {
+    const { b, c, nodes, connections } = chain()
+    const snapshot = structuredClone({ nodes, connections })
+    dup(nodes, connections, [b.id, c.id], 40, 40)
+    expect({ nodes, connections }).toEqual(snapshot)
+  })
+
+  it("選択内で完結する接続だけを新しいポート id へ張り替えてコピーする", () => {
+    const { b, c, nodes, connections } = chain()
+    const result = dup(nodes, connections, [b.id, c.id])
+
+    // A→B（入口）と C→D（出口）は落ち、B→C だけが残る
+    expect(result.connections).toHaveLength(1)
+    const newB = result.nodes.find((n) => n.name === "B")
+    const newC = result.nodes.find((n) => n.name === "C")
+    if (!newB || !newC) throw new Error("複製ノードがない")
+    expect(result.connections[0]).toEqual({
+      from_port_id: outOf(newB).id,
+      to_port_id: inOf(newC).id,
+    })
+  })
+
+  it("同じ out ポートからの fan-out も両方コピーされる", () => {
+    const a = makeNode("program", "A", 0, 0)
+    const b = makeNode("program", "B", 100, 0)
+    const c = makeNode("program", "C", 100, 100)
+    const nodes = [a, b, c]
+    const connections = [connect(a, b), connect(a, c)]
+    const result = dup(nodes, connections, [a.id, b.id, c.id])
+
+    expect(result.nodes).toHaveLength(3)
+    expect(result.connections).toHaveLength(2)
+    const newA = result.nodes.find((n) => n.name === "A")
+    if (!newA) throw new Error("複製ノードがない")
+    for (const conn of result.connections) {
+      expect(conn.from_port_id).toBe(outOf(newA).id)
+    }
+  })
+
+  it("start / end は選択に含まれていても複製しない", () => {
+    const start = makeNode("start", "開始", 0, 0)
+    const b = makeNode("program", "B", 100, 0)
+    const end = makeNode("end", "終了", 200, 0)
+    const nodes = [start, b, end]
+    const connections = [connect(start, b), connect(b, end)]
+    const result = dup(nodes, connections, [start.id, b.id, end.id])
+
+    expect(result.nodes.map((n) => n.name)).toEqual(["B"])
+    // start / end 側の線は「選択内で完結」しないので落ちる
+    expect(result.connections).toEqual([])
+  })
+
+  it("選択が空・start/end のみのときは空の結果を返す", () => {
+    const start = makeNode("start", "開始", 0, 0)
+    const end = makeNode("end", "終了", 200, 0)
+    const nodes = [start, end]
+    const connections = [connect(start, end)]
+
+    expect(dup(nodes, connections, [])).toEqual({ nodes: [], connections: [] })
+    expect(dup(nodes, connections, [start.id, end.id])).toEqual({
+      nodes: [],
+      connections: [],
+    })
+  })
+
+  it("kind 別設定・hooks・ポートの属性を引き継ぐ", () => {
+    const wait = makeNode("wait", "待つ", 0, 0)
+    const human: GraphNode = {
+      ...makeNode("human", "承認", 100, 0),
+      ports: [
+        { ...port("in", "in"), side: "left", offset: 0.25 },
+        {
+          ...port("out", "approve"),
+          name: "承認",
+          schema: { type: "string" },
+          side: "right",
+          offset: 0.75,
+        },
+        port("out", "reject"),
+      ],
+      human: {
+        assignment: {
+          strategy: "fixed",
+          approval_mode: "any",
+          units: [[RUN_STARTER]],
+        },
+      },
+    }
+    const program: GraphNode = {
+      ...makeNode("program", "実行", 200, 0),
+      program: { program_dir: "sendReply" },
+      hooks: [
+        {
+          hook_dir: "notify",
+          on_input: false,
+          on_output: true,
+          on_signal: false,
+        },
+      ],
+    }
+    const component: GraphNode = {
+      ...makeNode("component", "部品", 300, 0),
+      component: { component_loop_id: uuid() },
+    }
+    const nodes = [wait, human, program, component]
+    const result = dup(nodes, [], [wait.id, human.id, program.id, component.id])
+
+    const byName = new Map(result.nodes.map((n) => [n.name, n]))
+    expect(byName.get("待つ")?.wait).toEqual(wait.wait)
+    expect(byName.get("承認")?.human).toEqual(human.human)
+    expect(byName.get("実行")?.program).toEqual(program.program)
+    expect(byName.get("実行")?.hooks).toEqual(program.hooks)
+    // component 参照はそのまま（同じ子 loop を指す2つ目の配置）
+    expect(byName.get("部品")?.component).toEqual(component.component)
+
+    // ポートの io / key / name / schema / side / offset が保たれる
+    const newHuman = byName.get("承認")
+    if (!newHuman) throw new Error("複製ノードがない")
+    expect(newHuman.ports.map(({ id: _id, ...rest }) => rest)).toEqual(
+      human.ports.map(({ id: _id, ...rest }) => rest),
+    )
+  })
+
+  it("dx / dy を全ノードへ一律に適用し、相対配置を保つ", () => {
+    const { b, c, nodes, connections } = chain()
+    const result = dup(nodes, connections, [b.id, c.id], 40, -20)
+
+    const byName = new Map(result.nodes.map((n) => [n.name, n]))
+    expect(byName.get("B")?.position_x).toBe(b.position_x + 40)
+    expect(byName.get("B")?.position_y).toBe(b.position_y - 20)
+    expect(byName.get("C")?.position_x).toBe(c.position_x + 40)
+    expect(byName.get("C")?.position_y).toBe(c.position_y - 20)
+  })
+
+  it("元グラフでの並び順を保って返す（選択の指定順には依存しない）", () => {
+    const { b, c, nodes, connections } = chain()
+    const result = dup(nodes, connections, [c.id, b.id])
+    expect(result.nodes.map((n) => n.name)).toEqual(["B", "C"])
+  })
+})

package/_schemas/duplicate-selection.ts

@@ -0,0 +1,48 @@
+import type { GraphConnection, GraphNode } from "./graph.js"
+
+// 選択ノードのコピー＆ペースト・複製（ノードのコピー&ペーストと複数選択.md）。
+// 純関数（id 採番は newId で注入）。エディタとテストの両方から使う。
+//
+// グラフは全量置換 PUT なので、複製は「id を全部採番し直して足す」だけで成立する。
+// ポート数の制約（in は kind ごとに固定・out は1以上）や (io,key) のノード内一意は
+// ノードを丸ごと写すので自動的に保たれる。
+
+export const duplicateSelection = (params: {
+  nodes: GraphNode[]
+  connections: GraphConnection[]
+  selectedIds: readonly string[]
+  // 貼り付け位置の移動量（world 座標。選択の相対配置はそのまま保つ）
+  dx: number
+  dy: number
+  newId: () => string
+}): { nodes: GraphNode[]; connections: GraphConnection[] } => {
+  const { nodes, connections, selectedIds, dx, dy, newId } = params
+  const selected = new Set(selectedIds)
+
+  // start / end は回路の構造ノードなので複製しない（選択に混ざっていても落とす）。
+  // 並び順は元グラフのまま（選択の指定順に依存させない）
+  const portIdMap = new Map<string, string>()
+  const copied = nodes
+    .filter((n) => selected.has(n.id) && n.kind !== "start" && n.kind !== "end")
+    .map((n) => ({
+      ...n,
+      id: newId(),
+      ports: n.ports.map((p) => {
+        const portId = newId()
+        portIdMap.set(p.id, portId)
+        return { ...p, id: portId }
+      }),
+      position_x: n.position_x + dx,
+      position_y: n.position_y + dy,
+    }))
+
+  // 両端が複製対象のポートである線（＝選択内で完結する線）だけを張り替えて写す。
+  // 外部との線（入口・出口）はコピーしない
+  const copiedConnections = connections.flatMap((c) => {
+    const from = portIdMap.get(c.from_port_id)
+    const to = portIdMap.get(c.to_port_id)
+    return from && to ? [{ from_port_id: from, to_port_id: to }] : []
+  })
+
+  return { nodes: copied, connections: copiedConnections }
+}

package/_schemas/extract-component.test.ts

@@ -110,10 +110,20 @@ describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
     expect(ok.ok).toBe(true)
   })
 
-  it("空・1ノードのみ・start/end 含みは拒否する", () => {
+  it("1ノード選択：そのノードが入口、その out が出口になる", () => {
+    const { a, b, c, nodes, connections } = chain()
+    const result = analyzeExtractSelection(nodes, connections, [b.id])
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.entryNodeId).toBe(b.id)
+    expect(result.exitPortId).toBe(outOf(b).id)
+    expect(result.internal).toEqual([])
+    expect(result.inbound).toEqual([connect(a, b)])
+    expect(result.outbound).toEqual([connect(b, c)])
+  })
+
+  it("空・start/end 含みは拒否する", () => {
     const { b, nodes, connections } = chain()
     expect(analyzeExtractSelection(nodes, connections, []).ok).toBe(false)
-    expect(analyzeExtractSelection(nodes, connections, [b.id]).ok).toBe(false)
 
     const start = makeNode("start", "開始")
     const withStart = [...nodes, start]
@@ -217,4 +227,43 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     void b
     void c
   })
+
+  it("1ノード選択：start.main → ノード → end.in と配線され、親では component ノードに置き換わる", () => {
+    const { a, b, c, nodes, connections } = chain()
+    const childStartOutPortId = uuid()
+    const childEndInPortId = uuid()
+    const plan = buildExtractPlan({
+      nodes,
+      connections,
+      selectedIds: [b.id],
+      name: "待つだけ",
+      componentLoopId: uuid(),
+      childStartOutPortId,
+      childEndInPortId,
+      newId: uuid,
+    })
+    if (!plan.ok) throw new Error(plan.reason)
+    expect(plan.childNodes).toHaveLength(1)
+    const [nb] = plan.childNodes
+    if (!nb) throw new Error("コピーがない")
+    expect(nb.wait).toEqual({ wait_type: "duration", duration_seconds: 90 })
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: childStartOutPortId,
+      to_port_id: inOf(nb).id,
+    })
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: outOf(nb).id,
+      to_port_id: childEndInPortId,
+    })
+    // 親：B が component ノードに置き換わり、A.main → group.in／group.main → C.in
+    expect(plan.parentNodes.some((n) => n.id === b.id)).toBe(false)
+    expect(plan.parentConnections).toContainEqual({
+      from_port_id: outOf(a).id,
+      to_port_id: inOf(plan.groupNode).id,
+    })
+    expect(plan.parentConnections).toContainEqual({
+      from_port_id: outOf(plan.groupNode).id,
+      to_port_id: inOf(c).id,
+    })
+  })
 })

package/_schemas/extract-component.ts

@@ -26,8 +26,10 @@ export const analyzeExtractSelection = (
   selectedIds: readonly string[],
 ): ExtractAnalysis => {
   const selected = new Set(selectedIds)
-  if (selected.size < 2) {
-    return { ok: false, reason: "2つ以上のノードを選択してください" }
+  // 1ノードからコンポーネント化できる（グループ化の「2つ以上」はエディタ側の
+  // 有効条件。コンポーネントの設定値（refs）と1ノードのコンポーネント化.md）
+  if (selected.size < 1) {
+    return { ok: false, reason: "ノードを選択してください" }
   }
   const selectedNodes = nodes.filter((n) => selected.has(n.id))
   const flow = selectedNodes.find((n) => n.kind === "start" || n.kind === "end")