@mawaru/sdk 0.13.0 → 0.15.0

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: { reply: 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

@@ -216,6 +216,26 @@ describe("duplicateSelection（選択ノードの複製）", () => {
     )
   })
 
+  it("手動ルート（waypoints）は dx / dy を適用して引き継ぐ", () => {
+    const { b, c, nodes, connections } = chain()
+    const manual = connections.map((conn, i) =>
+      i === 1
+        ? {
+            ...conn,
+            waypoints: [
+              { x: 150, y: 0 },
+              { x: 150, y: 100 },
+            ],
+          }
+        : conn,
+    )
+    const result = dup(nodes, manual, [b.id, c.id], 40, -20)
+    expect(result.connections[0]?.waypoints).toEqual([
+      { x: 190, y: -20 },
+      { x: 190, y: 80 },
+    ])
+  })
+
   it("dx / dy を全ノードへ一律に適用し、相対配置を保つ", () => {
     const { b, c, nodes, connections } = chain()
     const result = dup(nodes, connections, [b.id, c.id], 40, -20)

package/_schemas/duplicate-selection.ts

@@ -37,11 +37,27 @@ export const duplicateSelection = (params: {
     }))
 
   // 両端が複製対象のポートである線（＝選択内で完結する線）だけを張り替えて写す。
-  // 外部との線（入口・出口）はコピーしない
+  // 外部との線（入口・出口）はコピーしない。手動ルート（waypoints）は
+  // ノードと同じ移動量で写し、調整済みの形を保つ
   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 from && to
+      ? [
+          {
+            from_port_id: from,
+            to_port_id: to,
+            ...(c.waypoints
+              ? {
+                  waypoints: c.waypoints.map((p) => ({
+                    x: p.x + dx,
+                    y: p.y + dy,
+                  })),
+                }
+              : {}),
+          },
+        ]
+      : []
   })
 
   return { nodes: copied, connections: copiedConnections }

package/_schemas/extract-component.test.ts

@@ -4,18 +4,22 @@ import {
   buildExtractPlan,
 } from "./extract-component.js"
 import type { GraphNode } from "./graph.js"
-import type { GraphPort } from "./node.js"
+import type { GraphPort, JsonSchema } from "./node.js"
 
 // テスト用の決定的な uuid（graph.test.ts と同じ流儀）
 let seq = 0
 const uuid = () => `00000000-0000-4000-8000-${String(++seq).padStart(12, "0")}`
 
-const port = (io: "in" | "out", key: string): GraphPort => ({
+const port = (
+  io: "in" | "out",
+  key: string,
+  schema: JsonSchema = { type: "object" },
+): GraphPort => ({
   id: uuid(),
   io,
   key,
   name: key,
-  schema: { type: "object" },
+  schema,
 })
 
 const makeNode = (
@@ -62,44 +66,60 @@ const chain = () => {
   return { a, b, c, d, nodes, connections }
 }
 
-describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
+describe("analyzeExtractSelection（境界の分類と成立条件）", () => {
   it("直列の中間2ノード：入口・出口と内部/入口/出口線を分類する", () => {
     const { a, b, c, d, nodes, connections } = chain()
     const result = analyzeExtractSelection(nodes, connections, [b.id, c.id])
     if (!result.ok) throw new Error(result.reason)
-    expect(result.entryNodeId).toBe(b.id)
-    expect(result.exitPortId).toBe(outOf(c).id)
+    expect(result.entryPortIds).toEqual([inOf(b).id])
+    expect(result.exitPortIds).toEqual([outOf(c).id])
     expect(result.internal).toEqual([connect(b, c)])
     expect(result.inbound).toEqual([connect(a, b)])
     expect(result.outbound).toEqual([connect(c, d)])
   })
 
-  it("孤立した島（入出力なし）も抽出できる（entry/exit は null）", () => {
+  it("孤立した島（入出力なし）も抽出できる（入口・出口は空）", () => {
     const { b, c, nodes } = chain()
     const internalOnly = [connect(b, c)]
     const result = analyzeExtractSelection(nodes, internalOnly, [b.id, c.id])
     if (!result.ok) throw new Error(result.reason)
-    expect(result.entryNodeId).toBeNull()
-    expect(result.exitPortId).toBeNull()
+    expect(result.entryPortIds).toEqual([])
+    expect(result.exitPortIds).toEqual([])
   })
 
-  it("入口が2ノードになる選択は拒否する", () => {
+  it("入口が複数でも型が同じなら成立する（同型の合流）", () => {
     const { a, b, c, d, nodes, connections } = chain()
-    // A→B と D→C を追加：選択 {B, C} への外部入力が B と C の2ノードに入る
+    // A→B に加えて D→C：選択 {B, C} への外部入力が B.in と C.in の2ポートに入る。
+    // どちらの in も {type:"object"} なので成立する
     const withSecondEntry = [...connections, connect(d, c)]
     const result = analyzeExtractSelection(nodes, withSecondEntry, [b.id, c.id])
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.entryPortIds.sort()).toEqual([inOf(b).id, inOf(c).id].sort())
+    void a
+  })
+
+  it("入口の型が揃っていない選択は拒否する", () => {
+    const { a, b, d, nodes, connections } = chain()
+    // in の型が違うノードを選択に足し、外部から線を入れる
+    const e = {
+      ...makeNode("program", "E", 200, 200),
+      ports: [port("in", "in", { type: "string" }), port("out", "main")],
+    }
+    const withE = [...nodes, e]
+    const conns = [...connections, connect(d, e)]
+    const result = analyzeExtractSelection(withE, conns, [b.id, e.id])
     expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toContain("入口")
+    if (!result.ok) expect(result.reason).toContain("入口の型")
     void a
   })
 
-  it("出口が2ポートになる選択は拒否する（同一ポートからの fan-out は許す）", () => {
+  it("出口は複数ポートでも成立する（同一ポートからの fan-out は1出口扱い）", () => {
     const { a, b, c, d, nodes, connections } = chain()
     // B→D を追加：選択 {B, C} から外への出力が B.main と C.main の2ポート
     const twoExits = [...connections, connect(b, d)]
     const result = analyzeExtractSelection(nodes, twoExits, [b.id, c.id])
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toContain("出口")
+    if (!result.ok) throw new Error(result.reason)
+    expect(result.exitPortIds.sort()).toEqual([outOf(b).id, outOf(c).id].sort())
 
     // C.main → D に加えて C.main → A（同一ポートの fan-out）は出口1つ扱い
     const fanOut = [
@@ -107,13 +127,24 @@ describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
       { from_port_id: outOf(c).id, to_port_id: inOf(a).id },
     ]
     const ok = analyzeExtractSelection(nodes, fanOut, [b.id, c.id])
-    expect(ok.ok).toBe(true)
+    if (!ok.ok) throw new Error(ok.reason)
+    expect(ok.exitPortIds).toEqual([outOf(c).id])
+  })
+
+  it("1ノード選択：そのノードの in が入口、その 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.entryPortIds).toEqual([inOf(b).id])
+    expect(result.exitPortIds).toEqual([outOf(b).id])
+    expect(result.internal).toEqual([])
+    expect(result.inbound).toEqual([connect(a, b)])
+    expect(result.outbound).toEqual([connect(b, c)])
   })
 
-  it("空・1ノードのみ・start/end 含みは拒否する", () => {
+  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]
@@ -127,10 +158,20 @@ describe("analyzeExtractSelection（境界の分類と V1 制約）", () => {
 })
 
 describe("buildExtractPlan（子グラフと親置換の生成）", () => {
+  const childEndNode = (): GraphNode => ({
+    id: uuid(),
+    kind: "end",
+    name: "終了",
+    ports: [port("in", "in", {}), port("out", "main", {})],
+    hooks: [],
+    position_x: 560,
+    position_y: 200,
+  })
+
   const build = () => {
     const { a, b, c, d, nodes, connections } = chain()
     const childStartOutPortId = uuid()
-    const childEndInPortId = uuid()
+    const childEnd = childEndNode()
     const componentLoopId = uuid()
     const plan = buildExtractPlan({
       nodes,
@@ -139,7 +180,7 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
       name: "PRレビュー",
       componentLoopId,
       childStartOutPortId,
-      childEndInPortId,
+      childEnd,
       newId: uuid,
     })
     if (!plan.ok) throw new Error(plan.reason)
@@ -152,7 +193,7 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
       connections,
       plan,
       childStartOutPortId,
-      childEndInPortId,
+      childEnd,
       componentLoopId,
     }
   }
@@ -175,18 +216,20 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     expect(internal).toBeDefined()
   })
 
-  it("子：start.main → 入口ノード、出口ポート → end.in が配線される", () => {
-    const { plan, childStartOutPortId, childEndInPortId } = build()
+  it("子：start.main → 入口、出口ポート → end.in が配線される（出口1つは seed の in を使う）", () => {
+    const { plan, childStartOutPortId, childEnd } = build()
     const [nb, nc] = plan.childNodes
     if (!nb || !nc) throw new Error("コピーがない")
     expect(plan.childConnections).toContainEqual({
       from_port_id: childStartOutPortId,
       to_port_id: inOf(nb).id,
     })
+    // seed 済みの end.in がそのまま使われ、名前は出口ポート名になる
     expect(plan.childConnections).toContainEqual({
       from_port_id: outOf(nc).id,
-      to_port_id: childEndInPortId,
+      to_port_id: inOf(childEnd).id,
     })
+    expect(inOf(plan.childEnd).name).toBe(outOf(nc).name)
   })
 
   it("親：選択が groupNode に置き換わり、外部との線が in/main へ繋ぎ直される", () => {
@@ -199,6 +242,10 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     expect(plan.groupNode.name).toBe("PRレビュー")
     expect(plan.groupNode.position_x).toBe(150) // (100+200)/2
     expect(plan.groupNode.position_y).toBe(50) // (0+100)/2
+    // 出口1つ：out は互換の main 1口
+    expect(
+      plan.groupNode.ports.filter((p) => p.io === "out").map((p) => p.key),
+    ).toEqual(["main"])
 
     // 親 nodes：A, D, groupNode（B, C は消える）
     expect(plan.parentNodes.map((n) => n.id).sort()).toEqual(
@@ -217,4 +264,134 @@ describe("buildExtractPlan（子グラフと親置換の生成）", () => {
     void b
     void c
   })
+
+  it("複数入口（同型）：start.main から全入口へ fan-out し、親の同一起点は group.in への1本に畳まれる", () => {
+    // X.main が B と C の両方へ入る（今回の実例：開発.main → レビューと監視）
+    const { a, b, c, d, nodes, connections } = chain()
+    const conns = [
+      ...connections,
+      { from_port_id: outOf(a).id, to_port_id: inOf(c).id },
+    ]
+    const childStartOutPortId = uuid()
+    const plan = buildExtractPlan({
+      nodes,
+      connections: conns,
+      selectedIds: [b.id, c.id],
+      name: "レビュー",
+      componentLoopId: uuid(),
+      childStartOutPortId,
+      childEnd: childEndNode(),
+      newId: uuid,
+    })
+    if (!plan.ok) throw new Error(plan.reason)
+    const [nb, nc] = plan.childNodes
+    if (!nb || !nc) throw new Error("コピーがない")
+    // 子：start.main → B.in と C.in の両方
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: childStartOutPortId,
+      to_port_id: inOf(nb).id,
+    })
+    expect(plan.childConnections).toContainEqual({
+      from_port_id: childStartOutPortId,
+      to_port_id: inOf(nc).id,
+    })
+    // 親：A.main → group.in は1本だけ（重複線を作らない）
+    const inboundToGroup = plan.parentConnections.filter(
+      (conn) => conn.to_port_id === inOf(plan.groupNode).id,
+    )
+    expect(inboundToGroup).toEqual([
+      { from_port_id: outOf(a).id, to_port_id: inOf(plan.groupNode).id },
+    ])
+    void d
+  })
+
+  it("複数出口：出発ポートごとに end の in と group の out が生え、親は対応する out から繋ぎ直される", () => {
+    const { a, b, c, d, nodes, connections } = chain()
+    // B→D を追加：出口は B.main と C.main の2つ
+    const conns = [...connections, connect(b, d)]
+    const childEnd = childEndNode()
+    const plan = buildExtractPlan({
+      nodes,
+      connections: conns,
+      selectedIds: [b.id, c.id],
+      name: "レビュー",
+      componentLoopId: uuid(),
+      childStartOutPortId: uuid(),
+      childEnd,
+      newId: uuid,
+    })
+    if (!plan.ok) throw new Error(plan.reason)
+    const [nb, nc] = plan.childNodes
+    if (!nb || !nc) throw new Error("コピーがない")
+
+    // 子 end：in が出口の数だけある（1つ目は seed 再利用・2つ目は追加）
+    const endIns = plan.childEnd.ports.filter((p) => p.io === "in")
+    expect(endIns).toHaveLength(2)
+    // 出口ポート → 対応する end.in の配線
+    const endInByExit = new Map(
+      plan.childConnections
+        .filter((conn) => endIns.some((p) => p.id === conn.to_port_id))
+        .map((conn) => [conn.from_port_id, conn.to_port_id] as const),
+    )
+    expect(endInByExit.get(outOf(nc).id)).toBeDefined()
+    expect(endInByExit.get(outOf(nb).id)).toBeDefined()
+
+    // group：出口ごとの out（key は end.in の射影）
+    const groupOuts = plan.groupNode.ports.filter((p) => p.io === "out")
+    expect(groupOuts).toHaveLength(2)
+    expect(groupOuts.map((p) => p.key).sort()).toEqual(
+      endIns.map((p) => p.key).sort(),
+    )
+
+    // 親：C.main → D は「C.main に対応する out」→ D、B.main → D は「B.main に対応する out」→ D
+    const parentOutConns = plan.parentConnections.filter((conn) =>
+      groupOuts.some((p) => p.id === conn.from_port_id),
+    )
+    expect(parentOutConns).toHaveLength(2)
+    expect(new Set(parentOutConns.map((c2) => c2.to_port_id))).toEqual(
+      new Set([inOf(d).id]),
+    )
+    // 2本は別々の out から出る（同じ out からの fan-out ではない）
+    expect(new Set(parentOutConns.map((c2) => c2.from_port_id)).size).toBe(2)
+    void a
+  })
+
+  it("1ノード選択：start.main → ノード → end.in と配線され、親では component ノードに置き換わる", () => {
+    const { a, b, c, nodes, connections } = chain()
+    const childStartOutPortId = uuid()
+    const childEnd = childEndNode()
+    const plan = buildExtractPlan({
+      nodes,
+      connections,
+      selectedIds: [b.id],
+      name: "待つだけ",
+      componentLoopId: uuid(),
+      childStartOutPortId,
+      childEnd,
+      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: inOf(childEnd).id,
+    })
+    // 親：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,
+    })
+  })
 })