@mawaru/sdk 0.9.0 → 0.13.0

package/_schemas/ai-manifest.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { aiManifestSchema } from "./ai-manifest.js"
+import { AI_MODELS, aiManifestSchema } from "./ai-manifest.js"
 import { envelopeSchemaOf, instructionSchema } from "./port-spec.js"
 
 const envelope = envelopeSchemaOf({ type: "string" })
@@ -32,11 +32,18 @@ describe("aiManifestSchema", () => {
       outputs: { main: envelope },
     })
     expect(manifest.name).toBeUndefined()
-    expect(manifest.model).toBe("claude-opus-4-8")
+    expect(manifest.model).toBe("claude-opus-5")
     expect(manifest.skills).toEqual([])
     expect(manifest.env).toEqual([])
   })
 
+  it("model は AI_MODELS の enum（バージョン固定。外の値は拒否）", () => {
+    for (const model of AI_MODELS) {
+      expect(aiManifestSchema.parse({ ...valid, model }).model).toBe(model)
+    }
+    expect(() => aiManifestSchema.parse({ ...valid, model: "opus" })).toThrow()
+  })
+
   it("prompt は必須・非空（repo に置く時点で完成品）", () => {
     expect(() => aiManifestSchema.parse({ ...valid, prompt: "" })).toThrow()
     const { prompt: _prompt, ...rest } = valid
@@ -77,7 +84,7 @@ describe("aiManifestSchema", () => {
   it("outputs は1件以上・key 自由（AI の複数出口＝分岐）", () => {
     expect(() => aiManifestSchema.parse({ ...valid, outputs: {} })).toThrow()
     expect(() =>
-      aiManifestSchema.parse({ ...valid, outputs: { draft: envelope } }),
+      aiManifestSchema.parse({ ...valid, outputs: { reply: envelope } }),
     ).not.toThrow()
     expect(() =>
       aiManifestSchema.parse({

package/_schemas/ai-manifest.ts

@@ -2,15 +2,18 @@ import { z } from "zod"
 import { jsonSchemaSchema } from "./node.js"
 import { isAiEnvelopeSchema, manifestInKeysViolation } from "./port-spec.js"
 
-// AI ノードのモデル選択肢（既定は Opus：下書き品質が価値の中心。費用はユーザー持ち）
+// AI ノードのモデル選択肢（既定は Opus：下書き品質が価値の中心。費用はユーザー持ち）。
+// エイリアス（"opus" 等）は採らずバージョンを固定する：実行のたびに黙って別モデルへ
+// 乗り換わると品質も費用も再現しないため。新モデルが出たらこの配列を足して SDK を publish する
 export const AI_MODELS = [
+  "claude-opus-5",
   "claude-opus-4-8",
   "claude-sonnet-5",
   "claude-haiku-4-5",
 ] as const
 export const aiModelSchema = z.enum(AI_MODELS)
 export type AiModel = z.infer<typeof aiModelSchema>
-export const DEFAULT_AI_MODEL = "claude-opus-4-8" satisfies AiModel
+export const DEFAULT_AI_MODEL = "claude-opus-5" satisfies AiModel
 
 // nodes/ai/<dir>/config.json（実行repoの構造見直し）。AI ノードの定義（prompt/model/skills/
 // 入出力スキーマ/env）は repo 側が正で、エディタが取り込んで ports を自動生成する

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/graph.test.ts

@@ -153,8 +153,8 @@ describe("programConfigSchema", () => {
 
 describe("aiConfigSchema", () => {
   it("ai_dir を受け付ける（ref は省略可・日本語可）", () => {
-    expect(aiConfigSchema.parse({ ai_dir: "draftReply" })).toEqual({
-      ai_dir: "draftReply",
+    expect(aiConfigSchema.parse({ ai_dir: "replyComposer" })).toEqual({
+      ai_dir: "replyComposer",
     })
     expect(
       aiConfigSchema.parse({ ai_dir: "返信下書き", ref: "develop" }).ref,
@@ -181,14 +181,12 @@ describe("humanConfigSchema", () => {
 
   // 承認ビューは不透明なキー（program_dir / ai_dir と同じ）。実在するか・そのテナントが
   // 選べるかは mawaru 側のカタログ（非公開）と保存 API が見るので、ここは形だけ
-  it("承認ビューとそのパラメータを受け付ける", () => {
+  it("承認ビューを受け付ける", () => {
     const parsed = humanConfigSchema.parse({
       assignment: {},
       view: "acme/invoice",
-      view_config: { threshold: 1000 },
     })
     expect(parsed.view).toBe("acme/invoice")
-    expect(parsed.view_config).toEqual({ threshold: 1000 })
   })
 
   it("空のビューキーは拒否する", () => {
@@ -627,12 +625,13 @@ describe("saveGraphBodySchema（kind 別ポート構成）", () => {
 })
 
 describe("saveGraphBodySchema（型の接続バリデーション）", () => {
-  it("human の reject → ai の instruction は許可。ai の in や ai 以外は拒否", () => {
+  // 接続の可否は kind ではなく型で決まる（reject と instruction は両端とも
+  // instructionSchema() で固定されているので、型検証だけで組み合わせが決まる）
+  // → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
+  it("human の reject → ai の instruction は型が一致するので許可", () => {
     const human = humanNode()
     const ai = aiNode()
-    const prog = programNode()
     const rejectPort = outByKey(human, "reject")
-    // 差し戻しは指示の口（instruction）へ
     expect(() =>
       saveGraphBodySchema.parse({
         nodes: [human, ai],
@@ -644,40 +643,39 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
         ],
       }),
     ).not.toThrow()
-    // 上流データの口（in）には繋げない（意味の違う入力を fan-in させない）
-    expect(() =>
-      saveGraphBodySchema.parse({
-        nodes: [human, ai],
-        connections: [
-          { from_port_id: rejectPort.id, to_port_id: inByKey(ai, "in").id },
-        ],
-      }),
-    ).toThrow(/instruction/)
-    // ai 以外にも繋げない
+  })
+
+  it("reject は ai 以外へも繋げる（接続鏡映の in が指示型を採用する）", () => {
+    const human = humanNode()
+    const prog = programNode()
     expect(() =>
       saveGraphBodySchema.parse({
         nodes: [human, prog],
         connections: [
-          { from_port_id: rejectPort.id, to_port_id: inOf(prog).id },
+          {
+            from_port_id: outByKey(human, "reject").id,
+            to_port_id: inOf(prog).id,
+          },
         ],
       }),
-    ).toThrow(/instruction/)
+    ).not.toThrow()
   })
 
-  it("instruction ポートに繋げるのは human の reject だけ", () => {
-    const ai = aiNode()
-    const prog = programNode()
+  it("instruction ポートには型の合わない出力を繋げない（kind ではなく型で弾く）", () => {
+    const upstream = aiNode()
+    const downstream = aiNode()
+    // ai.main は封筒型 { data, description }、instruction は { prompt, files }
     expect(() =>
       saveGraphBodySchema.parse({
-        nodes: [prog, ai],
+        nodes: [upstream, downstream],
         connections: [
           {
-            from_port_id: outOf(prog).id,
-            to_port_id: inByKey(ai, "instruction").id,
+            from_port_id: outOf(upstream).id,
+            to_port_id: inByKey(downstream, "instruction").id,
           },
         ],
       }),
-    ).toThrow(/instruction ポートに接続できるのは/)
+    ).toThrow(/適合しません/)
   })
 
   it("human の in はどの型でも接続できる（封筒型の制約は課さない）", () => {
@@ -1068,7 +1066,7 @@ describe("saveGraphBodySchema：コンポーネントノード（component kind
         nodes: [prog, comp],
         connections: [connect(prog, comp)],
       }),
-    ).toThrow(/入力契約に適合しません/)
+    ).toThrow(/適合しません/)
     // 適合（string → string）なら通る
     const okComp = componentNode({ type: "string" })
     expect(() =>

package/_schemas/graph.ts

@@ -148,8 +148,6 @@ export const humanConfigSchema = z.object({
   // どのキーが実在するか・そのテナントが選べるかは保存時に mawaru 側が検証する
   // （カタログは非公開。@mawaru/common の approval-view.ts）。省略時は標準ビュー
   view: z.string().min(1).optional(),
-  // ビューに渡すパラメータ（列・ラベル・閾値など）。形はビューごとに違うので任意の JSON
-  view_config: z.unknown().nullish(),
   assignment: z
     .object({
       strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -482,64 +480,24 @@ export const saveGraphBodySchema = z
         })
       }
 
-      // human の reject の接続先は AI の instruction ポートのみ。
-      // 差し戻しは「元のセッションに指示を与える」操作で、上流データの口（in）とは
-      // 意味が違う（docs/tasks/wip/ポートスキーマのany撲滅.md）
-      if (
-        fromNode.kind === "human" &&
-        from.key === "reject" &&
-        !(toNode.kind === "ai" && to.key === AI_INSTRUCTION_PORT_KEY)
-      ) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["connections", i, "to_port_id"],
-          message:
-            "差し戻し（reject）の接続先は AI ノードの instruction ポートのみです",
-        })
-      }
-
-      // instruction ポートに繋げるのは human の reject だけ（データを流し込ませない）
-      if (
-        toNode.kind === "ai" &&
-        to.key === AI_INSTRUCTION_PORT_KEY &&
-        !(fromNode.kind === "human" && from.key === "reject")
-      ) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["connections", i, "to_port_id"],
-          message:
-            "instruction ポートに接続できるのは human の差し戻し（reject）だけです",
-        })
-      }
-
+      // 差し戻し（reject）と instruction の組み合わせは kind で縛らない：両端とも
+      // instructionSchema()（{ prompt, files }）で型が固定されているので、下の型検証だけで
+      // 「型が合う口にしか繋がらない」が成立する。差し戻し先が AI である必要はない
+      // （{ prompt, files } を受ける program へも繋げる）
+
+      // 型検証は kind によらず常に 伝播型（out） ⊆ 伝播型（in）。
+      // 未宣言は unknown＝判断できないので通す（作りかけのグラフを保存できなくしない）。
+      // 接続鏡映する口（program / ai の in）とコピー宣言のビューは接続元の型を採用する
+      // ので自明に通り、実質の検証対象は宣言で固定された口
+      // （component の契約・ai の instruction・宣言のあるビューの human.in）になる
+      // → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
       const fromSchema = resolved.get(conn.from_port_id) ?? from.schema
-
-      // human の in はどの型でも接続できる（上流が AI なら封筒 { data, description }、
-      // それ以外は input 全体を data として表示する。型制約は課さない）
-
-      // program の in への接続は 伝播型 ⊆ 宣言スキーマ。in は接続鏡映（sticky）なので
-      // 具体型の接続では自明に通り、接続元が未宣言 × 宣言維持のときだけ従来の意味を持つ
-      // （未宣言は unknown＝判断できないので通す。作りかけのグラフを保存できなくしない）
       const toSchema = resolved.get(conn.to_port_id) ?? to.schema
-      if (toNode.kind === "program" && !isSchemaSubset(fromSchema, toSchema)) {
+      if (!isSchemaSubset(fromSchema, toSchema)) {
         ctx.addIssue({
           code: "custom",
           path: ["connections", i, "to_port_id"],
-          message:
-            "接続元の型が program の入力スキーマに適合しません（伝播型 ⊆ 宣言スキーマ）",
-        })
-      }
-
-      // component の in は子 loop の契約（焼き込み済み宣言）。program と同じ包含チェック
-      if (
-        toNode.kind === "component" &&
-        !isSchemaSubset(fromSchema, toSchema)
-      ) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["connections", i, "to_port_id"],
-          message:
-            "接続元の型がコンポーネントの入力契約に適合しません（伝播型 ⊆ 契約）",
+          message: `「${fromNode.name}」の出力が「${toNode.name}」の入力スキーマに適合しません`,
         })
       }
     })

package/_schemas/port-spec.test.ts

@@ -153,7 +153,7 @@ describe("kindPortsViolation（kind 別ポート構成）", () => {
   it("ai は out の key 自由・複数可。in は in / instruction の2口固定（AI の複数出口）", () => {
     const ins = [port("in", "in"), port("in", "instruction")]
     expect(kindPortsViolation("ai", [...ins, port("out", "main")])).toBeNull()
-    expect(kindPortsViolation("ai", [...ins, port("out", "draft")])).toBeNull()
+    expect(kindPortsViolation("ai", [...ins, port("out", "reply")])).toBeNull()
     expect(
       kindPortsViolation("ai", [
         ...ins,
@@ -219,7 +219,10 @@ describe("kindPortsViolation（kind 別ポート構成）", () => {
 describe("型伝播（導出ポートの解決）", () => {
   const envelope = envelopeSchemaOf({ type: "string" })
 
-  it("ai → human 直結：approve は封筒を剥がした data 型、reject は指示エンベロープ", () => {
+  // human の in / approve はビューの宣言をそのまま転写する（上流の kind は見ない）。
+  // sdk はカタログを知らないので、呼び出し元が viewPortSchemasOf で解決して渡す
+  // → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
+  it("ai → human 直結（コピー宣言）：in も approve も上流の out と同型、reject は指示エンベロープ", () => {
     const aiOut = port("out", "main", envelope)
     const ai = {
       id: uuid(),
@@ -237,12 +240,99 @@ describe("型伝播（導出ポートの解決）", () => {
     const resolved = resolvePortSchemas(
       [ai, human],
       [{ from_port_id: aiOut.id, to_port_id: humanIn.id }],
+      { viewPortSchemasOf: () => ({ in: "T", out: "T" }) },
     )
+    // 上流が AI でも中身を取り出さない：AI の出力形式がそのまま下流へ流れる
     expect(resolved.get(humanIn.id)).toEqual(envelope)
-    expect(resolved.get(approve.id)).toEqual({ type: "string" })
+    expect(resolved.get(approve.id)).toEqual(envelope)
     expect(resolved.get(reject.id)).toEqual(instructionSchema())
   })
 
+  describe("承認ビューの宣言を human のポートへ転写する", () => {
+    const viewIn = {
+      type: "object",
+      properties: {
+        data: {
+          type: "object",
+          properties: { prs: { type: "array", items: { type: "object" } } },
+          required: ["prs"],
+        },
+        description: { type: "string" },
+      },
+      required: ["data", "description"],
+    }
+    const viewOut = {
+      type: "object",
+      properties: { prs: { type: "array", items: { type: "object" } } },
+      required: ["prs"],
+    }
+    const build = (upstreamKind: string, upstreamOut: JsonSchema) => {
+      const out = port("out", "main", upstreamOut)
+      const upstream = {
+        id: uuid(),
+        kind: upstreamKind,
+        ports: [port("in", "in"), out],
+      }
+      const humanIn = port("in", "in")
+      const approve = port("out", "approve")
+      const human = {
+        id: uuid(),
+        kind: "human",
+        ports: [humanIn, approve, port("out", "reject")],
+      }
+      return { upstream, human, out, humanIn, approve }
+    }
+
+    it("宣言のあるビューは上流の kind に依らず同じ型になる", () => {
+      for (const kind of ["ai", "program"]) {
+        const { upstream, human, out, humanIn, approve } = build(kind, envelope)
+        const resolved = resolvePortSchemas(
+          [upstream, human],
+          [{ from_port_id: out.id, to_port_id: humanIn.id }],
+          { viewPortSchemasOf: () => ({ in: viewIn, out: viewOut }) },
+        )
+        expect(resolved.get(humanIn.id)).toEqual(viewIn)
+        expect(resolved.get(approve.id)).toEqual(viewOut)
+      }
+    })
+
+    it("上流の out は書き換えない（逆伝播しない）", () => {
+      const { upstream, human, out, humanIn } = build("ai", envelope)
+      const resolved = resolvePortSchemas(
+        [upstream, human],
+        [{ from_port_id: out.id, to_port_id: humanIn.id }],
+        { viewPortSchemasOf: () => ({ in: viewIn, out: viewOut }) },
+      )
+      expect(resolved.get(out.id)).toEqual(envelope)
+    })
+
+    it("コピー宣言（標準ビュー）は上流の型をそのまま in と approve へ流す", () => {
+      const { upstream, human, out, humanIn, approve } = build("ai", envelope)
+      const resolved = resolvePortSchemas(
+        [upstream, human],
+        [{ from_port_id: out.id, to_port_id: humanIn.id }],
+        { viewPortSchemasOf: () => ({ in: "T", out: "T" }) },
+      )
+      expect(resolved.get(humanIn.id)).toEqual(envelope)
+      expect(resolved.get(approve.id)).toEqual(envelope)
+    })
+
+    it("未接続でも宣言で固定される", () => {
+      const humanIn = port("in", "in")
+      const approve = port("out", "approve")
+      const human = {
+        id: uuid(),
+        kind: "human",
+        ports: [humanIn, approve, port("out", "reject")],
+      }
+      const resolved = resolvePortSchemas([human], [], {
+        viewPortSchemasOf: () => ({ in: viewIn, out: viewOut }),
+      })
+      expect(resolved.get(humanIn.id)).toEqual(viewIn)
+      expect(resolved.get(approve.id)).toEqual(viewOut)
+    })
+  })
+
   it("ai → wait → human：素通しで封筒型が伝播し、reject は指示エンベロープのまま", () => {
     // ai の in は宣言型（nodes/ai/<dir>/config.json の inputs.in 由来。実行repoの構造見直し）
     const aiInSchema = {