@mawaru/sdk 0.39.0 → 0.41.0

package/_schemas/graph.test.ts

@@ -174,20 +174,26 @@ describe("humanConfigSchema", () => {
     ).toThrow(/担当/)
   })
 
-  // 承認ビューは不透明なキー（program_dir / ai_dir と同じ）。実在するか・そのテナントが
-  // 選べるかは mawaru 側のカタログ（非公開）と保存 API が見るので、ここは形だけ
-  it("承認ビューを受け付ける", () => {
+  // 実装は nodes/human/ 直下のディレクトリ名（program_dir / ai_dir と同じ）。repo にあるかは保存 API が見る
+  it("実装（human_dir・ref）を受け付ける", () => {
     const parsed = humanConfigSchema.parse({
       assignment: { units: [[uuid()]] },
-      view: "acme/invoice",
+      human_dir: "invoice-review",
+      ref: "try-view",
     })
-    expect(parsed.view).toBe("acme/invoice")
+    expect(parsed.human_dir).toBe("invoice-review")
+    expect(parsed.ref).toBe("try-view")
   })
 
-  it("空のビューキーは拒否する", () => {
-    expect(() =>
-      humanConfigSchema.parse({ assignment: { units: [[uuid()]] }, view: "" }),
-    ).toThrow()
+  it("空・パスの human_dir は拒否する", () => {
+    for (const human_dir of ["", "a/b", "..", "a\\b"]) {
+      expect(() =>
+        humanConfigSchema.parse({
+          assignment: { units: [[uuid()]] },
+          human_dir,
+        }),
+      ).toThrow()
+    }
   })
 
   it("fixed：1ユニット（複数人の and/or）を受け付ける", () => {

package/_schemas/graph.ts

@@ -156,10 +156,19 @@ export type AssignMember = z.infer<typeof assignMemberSchema>
 // メンバーが tenant の membership であることの検証は保存 API 側で行う
 // （docs/tasks/backlog/Human担当者の高度化（複数人承認とラウンドロビン）.md）
 export const humanConfigSchema = z.object({
-  // 承認 UI（承認ビュー）の識別子。program_dir / ai_dir と同じ「不透明なキー」で、
-  // どのキーが実在するか・そのテナントが選べるかは保存時に mawaru 側が検証する
-  // （カタログは非公開。@mawaru/common の approval-view.ts）。省略時は標準ビュー
-  view: z.string().min(1).optional(),
+  // 実装（承認画面と入出力の宣言）の置き場所：実行 repo の nodes/human/ 直下のディレクトリ名。
+  // program_dir / ai_dir と同じ。省略時は mawaru 内蔵の標準の承認画面
+  // （docs/tasks/wip/承認ビューの顧客repo配置.md の「human ノードの実装として置く」）
+  human_dir: z
+    .string()
+    .min(1)
+    .refine(
+      (v) => !v.includes("/") && !v.includes("\\") && v !== "." && v !== "..",
+      "human_dir は nodes/human/ 直下のディレクトリ名で指定してください",
+    )
+    .optional(),
+  // 読むブランチ（省略時はデフォルトブランチ）。publish でその先頭の commit に固定する
+  ref: z.string().min(1).optional(),
   assignment: z
     .object({
       strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -293,8 +302,8 @@ export const graphNodeSchema = z.object({
   // 表示アイコン（全 kind 共通の任意設定。human はフロントが担当から導出するので通常設定しない）
   icon: nodeIconSchema.optional(),
   // Slack ビュー（全 kind 共通の任意設定。実行中（human は承認待ち）・完了メッセージの見せ方）。
-  // human の view と同じ「不透明なキー」で、選べる key は GET slack-views が返す。
-  // <slug>/<name> は実行 repo の views/slack/<name>/（@mawaru/sdk/slack-view の契約で書く）。
+  // human の view と同じ「不透明なキー」で、選べる key は GET views/slack が返す。
+  // <slug>/<name> は実行 repo の views/slack/<name>/（@mawaru/sdk/views/slack の契約で書く）。
   // 保存時に mawaru が見るのは common/* の実在と <slug>/* の可視性だけ。
   // 省略＝承認待ちは承認ボタンだけ・完了は ✅ の1行（データは出さない）。
   // ポートの型には一切影響しない

package/_schemas/human-manifest.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest"
+import { humanManifestSchema } from "./human-manifest.js"
+import { fileSchema, instructionSchema } from "./port-spec.js"
+
+const pr = {
+  type: "object",
+  properties: {
+    title: { type: "string", description: "PR のタイトル" },
+    gifs: { type: "array", items: fileSchema() },
+  },
+  required: ["title"],
+}
+
+const messagesOf = (value: unknown) => {
+  const parsed = humanManifestSchema.safeParse(value)
+  return parsed.success ? [] : parsed.error.issues.map((i) => i.message)
+}
+
+describe("humanManifestSchema（nodes/human/<dir>/config.json）", () => {
+  it("in・approve・reject を書いた宣言を通す（追加の出口も書ける）", () => {
+    const config = {
+      inputs: { in: { schema: pr } },
+      outputs: {
+        approve: { type: "array", items: pr },
+        reject: instructionSchema(),
+        notion: pr,
+      },
+    }
+    // refs はエディタが転写する生成物なので、無ければ空になる
+    expect(humanManifestSchema.parse(config)).toEqual({ ...config, refs: {} })
+  })
+
+  it("in・approve・reject のどれかが無ければ弾く（省略したときの決まりは無い）", () => {
+    const full = {
+      inputs: { in: { schema: pr } },
+      outputs: { approve: pr, reject: instructionSchema() },
+    }
+    const violation =
+      "human のポート構成は in(in) と out(approve / reject) が必須です（out は追加できます）"
+    expect(messagesOf({ ...full, inputs: {} })).toEqual([violation])
+    expect(messagesOf({ ...full, outputs: { approve: pr } })).toEqual([
+      violation,
+    ])
+    expect(
+      messagesOf({ ...full, outputs: { reject: instructionSchema() } }),
+    ).toEqual([violation])
+    expect(humanManifestSchema.safeParse({}).success).toBe(false)
+  })
+
+  it("in 以外の入口は弾く", () => {
+    expect(
+      humanManifestSchema.safeParse({
+        inputs: { in: { schema: pr }, instruction: { schema: pr } },
+        outputs: { approve: pr, reject: instructionSchema() },
+      }).success,
+    ).toBe(false)
+  })
+
+  it('上流のコピー（"T"）は書けない（型は具体的に書く）', () => {
+    expect(
+      humanManifestSchema.safeParse({
+        inputs: { in: { schema: "T" } },
+        outputs: { approve: "T", reject: instructionSchema() },
+      }).success,
+    ).toBe(false)
+  })
+})

package/_schemas/human-manifest.ts

@@ -0,0 +1,31 @@
+import { z } from "zod"
+import { jsonSchemaSchema, portKeySchema } from "./node.js"
+import { kindPortsViolation } from "./port-spec.js"
+
+// 顧客 repo の nodes/human/<dir>/config.json（human ノードの実装の入出力の宣言）。
+// program / AI の config.json と同じく、エディタがディレクトリを選んだときに inputs / outputs から
+// ports を起こし、ポートの編集は保存時にここへ書き戻される（実行時の正は ports テーブルのまま）。
+// 形は AI に揃える（inputs の値は { schema }、outputs の値は素の JSON Schema）。
+// 口の構成（in 1つ・approve / reject は必須・追加の出口は自由）は kind のポート構成の規則をそのまま使う
+export const humanManifestSchema = z
+  .object({
+    inputs: z.record(z.string(), z.object({ schema: jsonSchemaSchema })),
+    outputs: z.record(z.string(), jsonSchemaSchema),
+    // refs＝ループ変数の定義の転写（program と同じ。エディタのグラフ保存が一方向に書く生成物）
+    refs: z.record(portKeySchema, jsonSchemaSchema).default({}),
+  })
+  .superRefine((manifest, ctx) => {
+    const violation = kindPortsViolation("human", [
+      ...Object.keys(manifest.inputs).map((key) => ({
+        io: "in" as const,
+        key,
+      })),
+      ...Object.keys(manifest.outputs).map((key) => ({
+        io: "out" as const,
+        key,
+      })),
+    ])
+    if (violation) ctx.addIssue({ code: "custom", message: violation })
+  })
+
+export type HumanManifest = z.infer<typeof humanManifestSchema>

package/_schemas/port-spec.test.ts

@@ -153,11 +153,17 @@ describe("kindPortsViolation（kind 別ポート構成）", () => {
   })
 })
 
+// 実装（nodes/human/<dir>/）を指す human にする
+const withHumanDir = <N extends { kind: string }>(nodes: N[]) =>
+  nodes.map((node) =>
+    node.kind === "human" ? { ...node, human: { human_dir: "review" } } : node,
+  )
+
 describe("型伝播（導出ポートの解決）", () => {
   it.each([
     "notion_task",
     "main",
-  ])("Humanの追加出口 %s の宣言型は承認ビューの型で上書きしない", (key) => {
+  ])("Humanの追加出口 %s の宣言型は伝播で上書きしない", (key) => {
     const extra = port("out", key, {
       type: "object",
       properties: { title: { type: "string" } },
@@ -173,14 +179,10 @@ describe("型伝播（導出ポートの解決）", () => {
         extra,
       ],
     }
-    const resolved = resolvePortSchemas([human], [], {
-      viewPortSchemasOf: () => ({
-        in: { type: "string" },
-        approve: { type: "string" },
-        reject: { type: "string" },
-      }),
-    })
-    expect(resolved.get(extra.id)).toEqual(extra.schema)
+    for (const nodes of [[human], withHumanDir([human])]) {
+      const resolved = resolvePortSchemas(nodes, [])
+      expect(resolved.get(extra.id)).toEqual(extra.schema)
+    }
   })
 
   // 伝播テスト用の任意の宣言型（中身の形に意味はない）
@@ -190,10 +192,9 @@ describe("型伝播（導出ポートの解決）", () => {
     required: ["text"],
   }
 
-  // human の in / approve / reject はビューの宣言をそのまま転写する（上流の kind は見ない）。
-  // sdk はカタログを知らないので、呼び出し元が viewPortSchemasOf で解決して渡す
-  // → docs/tasks/done/ポート型固定の撤去とセッション再開のポート属性化.md
-  it("ai → human 直結（コピー宣言）：in も approve も上流の out と同型、reject はビューの宣言型", () => {
+  // 実装を指さない human（標準の承認画面）は wait と同じ素通し。上流の kind は見ない
+  // → docs/tasks/wip/承認ビューの顧客repo配置.md の「ポート型」
+  it("実装を指さない human：in も approve も上流の out と同型、reject は標準の差し戻し", () => {
     const aiOut = port("out", "main", declaredOut)
     const ai = {
       id: uuid(),
@@ -211,13 +212,6 @@ describe("型伝播（導出ポートの解決）", () => {
     const resolved = resolvePortSchemas(
       [ai, human],
       [{ from_port_id: aiOut.id, to_port_id: humanIn.id }],
-      {
-        viewPortSchemasOf: () => ({
-          in: "T",
-          approve: "T",
-          reject: instructionSchema(),
-        }),
-      },
     )
     // 上流が AI でも中身を取り出さない：AI の出力形式がそのまま下流へ流れる
     expect(resolved.get(humanIn.id)).toEqual(declaredOut)
@@ -225,25 +219,17 @@ describe("型伝播（導出ポートの解決）", () => {
     expect(resolved.get(reject.id)).toEqual(instructionSchema())
   })
 
-  describe("承認ビューの宣言を human のポートへ転写する", () => {
+  describe("実装（nodes/human/<dir>/）を指す human は program / ai と同じ", () => {
     const viewIn = {
       type: "object",
-      properties: {
-        data: {
-          type: "object",
-          properties: { prs: { type: "array", items: { type: "object" } } },
-          required: ["prs"],
-        },
-        description: { type: "string" },
-      },
-      required: ["data", "description"],
+      properties: { prs: { type: "array", items: { type: "object" } } },
+      required: ["prs"],
     }
     const viewOut = {
       type: "object",
-      properties: { prs: { type: "array", items: { type: "object" } } },
-      required: ["prs"],
+      properties: { merged: { type: "boolean" } },
+      required: ["merged"],
     }
-    // reject もビューの宣言（具体型のみ。コピー指示は意味を持たない）
     const viewReject = {
       type: "object",
       properties: { reason: { type: "string" } },
@@ -256,18 +242,19 @@ describe("型伝播（導出ポートの解決）", () => {
         kind: upstreamKind,
         ports: [port("in", "in"), out],
       }
-      const humanIn = port("in", "in")
-      const approve = port("out", "approve")
-      const reject = port("out", "reject")
+      const humanIn = port("in", "in", viewIn)
+      const approve = port("out", "approve", viewOut)
+      const reject = port("out", "reject", viewReject)
       const human = {
         id: uuid(),
         kind: "human",
+        human: { human_dir: "review" },
         ports: [humanIn, approve, reject],
       }
       return { upstream, human, out, humanIn, approve, reject }
     }
 
-    it("宣言のあるビューは上流の kind に依らず同じ型になる", () => {
+    it("out（approve・reject）は宣言のまま（上流の kind に依らない）", () => {
       for (const kind of ["ai", "program"]) {
         const { upstream, human, out, humanIn, approve, reject } = build(
           kind,
@@ -276,79 +263,33 @@ describe("型伝播（導出ポートの解決）", () => {
         const resolved = resolvePortSchemas(
           [upstream, human],
           [{ from_port_id: out.id, to_port_id: humanIn.id }],
-          {
-            viewPortSchemasOf: () => ({
-              in: viewIn,
-              approve: viewOut,
-              reject: viewReject,
-            }),
-          },
         )
-        expect(resolved.get(humanIn.id)).toEqual(viewIn)
         expect(resolved.get(approve.id)).toEqual(viewOut)
         expect(resolved.get(reject.id)).toEqual(viewReject)
       }
     })
 
-    it("上流の out は書き換えない（逆伝播しない）", () => {
+    it("in は上流の具体型を写す（program / ai の in と同じ鏡映）", () => {
       const { upstream, human, out, humanIn } = build("ai", declaredOut)
       const resolved = resolvePortSchemas(
         [upstream, human],
         [{ from_port_id: out.id, to_port_id: humanIn.id }],
-        {
-          viewPortSchemasOf: () => ({
-            in: viewIn,
-            approve: viewOut,
-            reject: viewReject,
-          }),
-        },
-      )
-      expect(resolved.get(out.id)).toEqual(declaredOut)
-    })
-
-    it("コピー宣言（標準ビュー）は上流の型をそのまま in と approve へ流す", () => {
-      const { upstream, human, out, humanIn, approve } = build(
-        "ai",
-        declaredOut,
-      )
-      const resolved = resolvePortSchemas(
-        [upstream, human],
-        [{ from_port_id: out.id, to_port_id: humanIn.id }],
-        {
-          viewPortSchemasOf: () => ({
-            in: "T",
-            approve: "T",
-            reject: viewReject,
-          }),
-        },
       )
       expect(resolved.get(humanIn.id)).toEqual(declaredOut)
-      expect(resolved.get(approve.id)).toEqual(declaredOut)
+      // 上流の out は書き換えない（逆伝播しない）
+      expect(resolved.get(out.id)).toEqual(declaredOut)
     })
 
-    it("未接続でも宣言で固定される", () => {
-      const humanIn = port("in", "in")
-      const approve = port("out", "approve")
-      const reject = port("out", "reject")
-      const human = {
-        id: uuid(),
-        kind: "human",
-        ports: [humanIn, approve, reject],
-      }
-      const resolved = resolvePortSchemas([human], [], {
-        viewPortSchemasOf: () => ({
-          in: viewIn,
-          approve: viewOut,
-          reject: viewReject,
-        }),
-      })
+    it("未接続の in は宣言のまま", () => {
+      const { human, humanIn, approve, reject } = build("ai", declaredOut)
+      const resolved = resolvePortSchemas([human], [])
       expect(resolved.get(humanIn.id)).toEqual(viewIn)
       expect(resolved.get(approve.id)).toEqual(viewOut)
       expect(resolved.get(reject.id)).toEqual(viewReject)
     })
   })
 
-  it("ai → wait → human：素通しで上流の宣言型が伝播し、reject はビュー宣言が無ければ未宣言", () => {
+  it("ai → wait → human：素通しで上流の宣言型が伝播し、reject は標準の差し戻し", () => {
     // ai の in は宣言型（nodes/ai/<dir>/config.json の inputs.in 由来。実行repoの構造見直し）
     const aiInSchema = {
       type: "object",
@@ -383,8 +324,8 @@ describe("型伝播（導出ポートの解決）", () => {
     expect(resolved.get(humanIn.id)).toEqual(declaredOut)
     // approve は in と同型（上流の kind による中身の取り出しはしない）
     expect(resolved.get(approve.id)).toEqual(declaredOut)
-    // reject はビューの宣言でのみ決まる（sdk 単体＝カタログ無しでは未宣言。型固定は廃止）
-    expect(resolved.get(reject.id)).toEqual(UNDECLARED_SCHEMA)
+    // reject は標準の承認画面の差し戻し（指示＋参考ファイル）
+    expect(resolved.get(reject.id)).toEqual(instructionSchema())
     // ai の in は宣言型がそのまま残る（const 扱いは廃止）
     expect(resolved.get(aiIn.id)).toEqual(aiInSchema)
   })

package/_schemas/port-spec.ts

@@ -2,7 +2,7 @@ import { z } from "zod"
 import type { GraphPort, JsonSchema, PortIo } from "./node.js"
 
 // ポートの kind 別型システム（docs/tasks/done/ポートのkind別仕様.md）。
-// 型の決まり方は2分類：宣言（program / ai の in・out。human はビューの宣言を転写）／
+// 型の決まり方は2分類：宣言（program / ai と、実装（nodes/human/<dir>/）を指す human の in・out）／
 // 導出（それ以外。接続元から伝播し、結果は ports.schema にキャッシュする）。
 // mawaru がコードで型を固定するポートは無い
 // （docs/tasks/done/ポート型固定の撤去とセッション再開のポート属性化.md）
@@ -265,9 +265,10 @@ export const kindPortsViolation = (
 // ---- 型伝播（導出ポートの解決） ----
 // 接続の両端は同じスキーマになる（値入力フォームのSchemaForm統一.md）。
 // wait は素通し（パラメトリック）ノード：in は接続元の out、out は in と同型。
-// human はビューの宣言を転写（"T" は素通しと同じ挙動。reject もビューの宣言）。
-// 宣言 out（program / ai）は触らない。
-// program / ai の in は**全ての口が**接続鏡映（sticky）：接続元 out が具体型のときだけ
+// human は実装（nodes/human/<dir>/）を指していれば program / ai と同じ宣言ノード、指していなければ
+// （標準の承認画面）wait と同じ素通し（approve は in と同型、reject は標準の差し戻し instructionSchema）。
+// 宣言 out（program / ai / 実装を指す human）は触らない。
+// program / ai（と実装を指す human）の in は**全ての口が**接続鏡映（sticky）：接続元 out が具体型のときだけ
 // 上書きし、未接続・型割れ・未宣言は現スキーマ（宣言）を維持する（鏡映結果は repo の
 // config.json へも書き戻される。docs/tasks/done/ポート編集のrepo書き戻し同期.md）
 
@@ -328,33 +329,11 @@ type PropagationNode = {
   id: string
   kind: string
   ports: GraphPort[]
+  // human のときだけ意味を持つ：実装（nodes/human/<dir>/）を指しているか
+  human?: { human_dir?: string | null } | null
 }
 type PortLink = { from_port_id: string; to_port_id: string }
 
-// 「上流の out をそのままコピーする」（in）／「in と同型」（approve）を表す指示。
-// 承認ビューのカタログ（@mawaru/common）の COPY_UPSTREAM と同じ値
-export const COPY_UPSTREAM_SCHEMA = "T"
-
-// ポートの型宣言：具体型か、上流からのコピー指示か
-export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA
-
-// 伝播のオプション。sdk は承認ビューのカタログを知らない（非公開。企業向けビューの
-// キーが npm 公開物に載るのを避ける）ので、呼び出し元が解決して渡す
-// → docs/tasks/done/ポート型固定の撤去とセッション再開のポート属性化.md
-export type PropagationOptions<N> = {
-  // human の in / approve / reject に転写する型（承認ビューの宣言）。null / undefined
-  // ならその node は対象外（human 以外）。上流ノードの kind は一切見ない。
-  // reject は具体型のみ（上流からのコピー指示は意味を持たない）
-  viewPortSchemasOf?: (node: N) =>
-    | {
-        in: DeclaredPortSchema
-        approve: DeclaredPortSchema
-        reject: JsonSchema
-      }
-    | null
-    | undefined
-}
-
 // end も導出ノード（各 in は上流から、out main は未宣言）。個別処理は
 // resolvePortSchemas 内で行うが、初期スキーマを未宣言にするためここに含める。
 // start も導出ノード：out main は接続先の in から逆向きに転写し、in は out と同型
@@ -365,10 +344,22 @@ const DERIVED_KINDS = new Set(["wait", "human", "end", "start", "join"])
 // in を接続鏡映（sticky）するノード：接続元 out が具体型のときだけ上書き
 const MIRROR_KINDS = new Set(["program", "ai"])
 
-const isDerivedPort = (kind: string, port: Pick<GraphPort, "io" | "key">) =>
-  DERIVED_KINDS.has(kind) &&
+// 実装（nodes/human/<dir>/）を指す human は program / ai と同じ（in は鏡映・out は宣言。
+// 型は config.json へ書き戻される）。指していない human は導出（標準の承認画面の素通し）
+const isMirrorNode = (node: PropagationNode): boolean =>
+  MIRROR_KINDS.has(node.kind) ||
+  (node.kind === "human" && Boolean(node.human?.human_dir))
+
+const isDerivedNode = (node: PropagationNode): boolean =>
+  DERIVED_KINDS.has(node.kind) && !isMirrorNode(node)
+
+const isDerivedPort = (
+  node: PropagationNode,
+  port: Pick<GraphPort, "io" | "key">,
+) =>
+  isDerivedNode(node) &&
   (port.io === "in" ||
-    (kind !== "human" && port.key === "main") ||
+    (node.kind !== "human" && port.key === "main") ||
     port.key === "approve" ||
     port.key === "reject")
 
@@ -380,7 +371,6 @@ const isDerivedPort = (kind: string, port: Pick<GraphPort, "io" | "key">) =>
 export const resolvePortSchemas = <N extends PropagationNode>(
   nodes: N[],
   connections: PortLink[],
-  options?: PropagationOptions<N>,
 ): Map<string, JsonSchema> => {
   const resolved = new Map<string, JsonSchema>()
   const kindByPortId = new Map<string, string>()
@@ -389,7 +379,7 @@ export const resolvePortSchemas = <N extends PropagationNode>(
       kindByPortId.set(port.id, node.kind)
       resolved.set(
         port.id,
-        isDerivedPort(node.kind, port) ? UNDECLARED_SCHEMA : port.schema,
+        isDerivedPort(node, port) ? UNDECLARED_SCHEMA : port.schema,
       )
     }
   }
@@ -480,9 +470,9 @@ export const resolvePortSchemas = <N extends PropagationNode>(
         }
         continue
       }
-      const isMirror = MIRROR_KINDS.has(node.kind)
-      if (!DERIVED_KINDS.has(node.kind) && !isMirror) continue
-      // 鏡映（program / ai）：全ての in が対象。具体型が流れてきたときだけ上書きする
+      const isMirror = isMirrorNode(node)
+      if (!isDerivedNode(node) && !isMirror) continue
+      // 鏡映（program / ai / 実装を指す human）：全ての in が対象。具体型が流れてきたときだけ上書きする
       // （宣言を未宣言で潰さない）。ai の in はどの口も対等（instruction の特別扱いは無い）
       if (isMirror) {
         for (const port of node.ports) {
@@ -497,36 +487,24 @@ export const resolvePortSchemas = <N extends PropagationNode>(
         }
         continue
       }
-      // 導出（wait / human）：in は上流から
+      // 導出（wait / 実装を指さない human）：in は上流から、out（main・approve）は in と同型。
+      // human の reject は標準の承認画面の差し戻し（指示＋参考ファイル）。
+      // 上流の out は書き換えない（逆伝播すると fan-out 先の型割れが config.json へ書き戻され、
+      // 元の出力宣言を黙って壊す。ズレは接続の型エラーで見せる）
       const inPort = node.ports.find((p) => p.io === "in")
       if (!inPort) continue
       const sources = inbound.get(inPort.id) ?? []
       const inSchema = mergeInboundSchemas(
         sources.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA),
       )
-      // 承認ビューの宣言を human のポートへそのまま転写する（上流ノードの kind は見ない）。
-      // "T" は「上流の out をコピー」（in）／「in と同型」（approve）。reject は具体型の宣言
-      // のみで、宣言が無ければ未宣言のまま（mawaru が型を焼き込むことはしない）。
-      // 上流の out は書き換えない：逆伝播すると fan-out 先のビューが食い違ったとき
-      // 型割れが config.json へ write-through され、元の出力宣言を黙って壊す。
-      // ズレは接続の型エラーで見せてユーザーの [修正する] で直す
-      const declared = options?.viewPortSchemasOf?.(node)
-      const effectiveIn =
-        declared && declared.in !== COPY_UPSTREAM_SCHEMA
-          ? declared.in
-          : inSchema
-      assign(inPort.id, effectiveIn)
+      assign(inPort.id, inSchema)
       for (const port of node.ports) {
-        if (port.io !== "out" || !isDerivedPort(node.kind, port)) continue
-        if (node.kind === "human" && port.key === "reject") {
-          if (declared) assign(port.id, declared.reject)
-          continue
-        }
+        if (port.io !== "out" || !isDerivedPort(node, port)) continue
         assign(
           port.id,
-          declared && declared.approve !== COPY_UPSTREAM_SCHEMA
-            ? declared.approve
-            : effectiveIn,
+          node.kind === "human" && port.key === "reject"
+            ? instructionSchema()
+            : inSchema,
         )
       }
     }
@@ -588,9 +566,8 @@ export const connectionAccepted = (
 export const propagateDerivedPorts = <N extends PropagationNode>(
   nodes: N[],
   connections: PortLink[],
-  options?: PropagationOptions<N>,
 ): N[] => {
-  const resolved = resolvePortSchemas(nodes, connections, options)
+  const resolved = resolvePortSchemas(nodes, connections)
   const flexiblePorts = resolveFlexiblePorts(nodes, connections)
   return nodes.map((node) => {
     let touched = false

package/dist/_cli/previewCommand.js

@@ -12,8 +12,8 @@ import { previewSlack, SLACK_SURFACES, } from "./previewSlack.js";
 // `mawaru login` のセッション（web と同じ membership）と、どのテナントのつもりで描くかの
 // MAWARU_TENANT_ID（repo の .env。create-loop スキルと同じ）が要る。
 // ファイルの集め方・cases.ts の評価・ケースの絞り込みは種類をまたいで共通で、種類ごとに「確かめ方」
-// （Slack は送る。承認ビューは repo へ移すときに足す）だけを差し替える
-// （docs/tasks/wip/Slackビューの顧客repo配置.md の「手元プレビュー」）
+// （Slack は送る）だけを差し替える
+// （docs/tasks/done/Slackビューの顧客repo配置.md の「手元プレビュー」）
 const USAGE = "使い方: npx mawaru preview <種類>/<名前> [--case <ケース名>] [--surface running|completed] [--channel <#名前|チャンネル ID>]\n" +
     "  例: npx mawaru preview slack/pr-review（views/slack/pr-review/ の cases.ts の全ケースを Slack に送る）";
 export const parsePreviewArgs = (args) => {
@@ -44,7 +44,7 @@ export const parsePreviewArgs = (args) => {
 };
 const PREVIEWERS = {
     slack: {
-        casesPath: "/slack-views/cases",
+        casesPath: "/views/slack/cases",
         run: ({ name, files, cases, options, api, log }) => {
             const channel = options.channel ?? process.env.MAWARU_PREVIEW_CHANNEL;
             if (!channel) {

package/dist/_cli/previewFiles.js

@@ -2,9 +2,8 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 // 手元プレビュー（`mawaru preview`）が読む、実行 repo の views/<種類>/<名前>/ のファイル。
 // 描画は mawaru API がやるので、ここは「対象を決めてファイルを集める」だけで、種類をまたいで共通
-// （docs/tasks/wip/Slackビューの顧客repo配置.md の「手元プレビュー」）
-// 手元プレビューできるビューの種類（views/ 直下のディレクトリ名）。承認ビューを repo へ移すときに
-// "approval" を足す（previewCommand.ts の振り分けにも足す）
+// （docs/tasks/done/Slackビューの顧客repo配置.md の「手元プレビュー」）
+// 手元プレビューできるビューの種類（views/ 直下のディレクトリ名。previewCommand.ts の振り分けと揃える）
 export const VIEW_KINDS = ["slack"];
 const dirsIn = (dir) => {
     try {

package/dist/_cli/previewSlack.d.ts

@@ -1,4 +1,4 @@
-import type { SlackViewCase } from "../slack-view.js";
+import type { SlackViewCase } from "../views/slack.js";
 import { type MawaruApi } from "./previewApi.js";
 export type SlackSurface = "running" | "completed";
 export declare const SLACK_SURFACES: SlackSurface[];

package/dist/_cli/previewSlack.js

@@ -42,7 +42,7 @@ export const previewSlack = async (params) => {
     let failed = 0;
     for (const testCase of cases) {
         for (const surface of surfaces) {
-            const result = expectOk("Slack への送信", await api("POST", "/slack-views/test-post", {
+            const result = expectOk("Slack への送信", await api("POST", "/views/slack/test-post", {
                 ...previewBodyOf(files, testCase, surface),
                 channel_id: channelId,
                 ...(thread

package/dist/_schemas/graph.d.ts

@@ -51,7 +51,8 @@ export declare const RUN_STARTER = "run_starter";
 export declare const assignMemberSchema: z.ZodUnion<readonly [z.ZodUUID, z.ZodLiteral<"run_starter">]>;
 export type AssignMember = z.infer<typeof assignMemberSchema>;
 export declare const humanConfigSchema: z.ZodObject<{
-    view: z.ZodOptional<z.ZodString>;
+    human_dir: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
     assignment: z.ZodObject<{
         strategy: z.ZodDefault<z.ZodEnum<{
             fixed: "fixed";
@@ -194,7 +195,8 @@ export declare const graphNodeSchema: z.ZodObject<{
         ref: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     human: z.ZodOptional<z.ZodObject<{
-        view: z.ZodOptional<z.ZodString>;
+        human_dir: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
         assignment: z.ZodObject<{
             strategy: z.ZodDefault<z.ZodEnum<{
                 fixed: "fixed";
@@ -295,7 +297,8 @@ export declare const saveGraphBodySchema: z.ZodObject<{
             ref: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         human: z.ZodOptional<z.ZodObject<{
-            view: z.ZodOptional<z.ZodString>;
+            human_dir: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
             assignment: z.ZodObject<{
                 strategy: z.ZodDefault<z.ZodEnum<{
                     fixed: "fixed";