@mawaru/sdk 0.5.0 → 0.8.0

package/dist/_schemas/graph.d.ts

@@ -23,6 +23,7 @@ export declare const graphNodeKindSchema: z.ZodEnum<{
     wait: "wait";
     start: "start";
     end: "end";
+    component: "component";
 }>;
 export type GraphNodeKind = z.infer<typeof graphNodeKindSchema>;
 export declare const waitConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -47,6 +48,8 @@ export declare const aiConfigSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AiConfig = z.infer<typeof aiConfigSchema>;
 export declare const humanConfigSchema: z.ZodObject<{
+    view: z.ZodOptional<z.ZodString>;
+    view_config: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
     assignment: z.ZodObject<{
         strategy: z.ZodDefault<z.ZodEnum<{
             fixed: "fixed";
@@ -60,6 +63,10 @@ export declare const humanConfigSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type HumanConfig = z.infer<typeof humanConfigSchema>;
+export declare const componentConfigSchema: z.ZodObject<{
+    component_loop_id: z.ZodUUID;
+}, z.core.$strip>;
+export type ComponentConfig = z.infer<typeof componentConfigSchema>;
 export declare const graphNodeHookSchema: z.ZodObject<{
     hook_dir: z.ZodString;
     ref: z.ZodOptional<z.ZodString>;
@@ -77,6 +84,7 @@ export declare const graphNodeSchema: z.ZodObject<{
         wait: "wait";
         start: "start";
         end: "end";
+        component: "component";
     }>;
     name: z.ZodString;
     ports: z.ZodArray<z.ZodObject<{
@@ -124,6 +132,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>;
+        view_config: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
         assignment: z.ZodObject<{
             strategy: z.ZodDefault<z.ZodEnum<{
                 fixed: "fixed";
@@ -136,6 +146,9 @@ export declare const graphNodeSchema: z.ZodObject<{
             units: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodUUID>>>;
         }, z.core.$strip>;
     }, z.core.$strip>>;
+    component: z.ZodOptional<z.ZodObject<{
+        component_loop_id: z.ZodUUID;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type GraphNode = z.infer<typeof graphNodeSchema>;
 export declare const graphConnectionSchema: z.ZodObject<{
@@ -153,6 +166,7 @@ export declare const saveGraphBodySchema: z.ZodObject<{
             wait: "wait";
             start: "start";
             end: "end";
+            component: "component";
         }>;
         name: z.ZodString;
         ports: z.ZodArray<z.ZodObject<{
@@ -200,6 +214,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>;
+            view_config: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
             assignment: z.ZodObject<{
                 strategy: z.ZodDefault<z.ZodEnum<{
                     fixed: "fixed";
@@ -212,6 +228,9 @@ export declare const saveGraphBodySchema: z.ZodObject<{
                 units: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodUUID>>>;
             }, z.core.$strip>;
         }, z.core.$strip>>;
+        component: z.ZodOptional<z.ZodObject<{
+            component_loop_id: z.ZodUUID;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     connections: z.ZodArray<z.ZodObject<{
         from_port_id: z.ZodUUID;

package/dist/_schemas/graph.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { graphPortSchema, jsonSchemaSchema, nodeKindSchema, portKeySchema, } from "./node.js";
-import { isAiEnvelopeSchema, isSchemaSubset, kindPortsViolation, resolvePortSchemas, } from "./port-spec.js";
+import { AI_INSTRUCTION_PORT_KEY, hasInboundConflict, isAiEnvelopeSchema, isSchemaSubset, kindPortsViolation, resolvePortSchemas, UNDECLARED_SCHEMA, } from "./port-spec.js";
 // refs＝ループ変数の袋（key→任意の JSON 値。上流出力の参照（refs）.md）。
 // run 開始時に定義から複製され、全 step に全量差し込まれる。
 // key はポート key と同じ規則（^[a-z][a-z0-9_]*$）。実行系ボディ
@@ -50,6 +50,7 @@ export const graphNodeKindSchema = nodeKindSchema.extract([
     "wait",
     "start",
     "end",
+    "component",
 ]);
 // Wait ノードの kind 別設定（node_waits の wait_type に対応する判別ユニオン）。
 // duration=経過秒、until=絶対時刻(ISO)、cron=cron 式（次回発火まで1回待つ）。
@@ -97,6 +98,12 @@ export const aiConfigSchema = z.object({
 // メンバーが 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(),
+    // ビューに渡すパラメータ（列・ラベル・閾値など）。形はビューごとに違うので任意の JSON
+    view_config: z.unknown().nullish(),
     assignment: z
         .object({
         strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -131,6 +138,12 @@ export const humanConfigSchema = z.object({
         });
     }),
 });
+// コンポーネントノードの kind 別設定（node_components に対応）。呼ぶ先は
+// kind='component' の loop。同 tenant・kind の検証と自 loop 参照の禁止は保存 API 側で行う
+// （docs/tasks/wip/コンポーネント（ループの部品化と再利用）.md）
+export const componentConfigSchema = z.object({
+    component_loop_id: z.uuid(),
+});
 // ノードにアタッチされた IOHook（node_hooks に対応。アタッチできるのは program ノードのみ）。
 // on_input / on_output / on_signal はアタッチ時に repo の config.json（hookManifestSchema）から
 // エディタが焼き込むスナップショット。ref 省略時はデフォルトブランチ
@@ -161,6 +174,7 @@ export const graphNodeSchema = z.object({
     program: programConfigSchema.optional(),
     ai: aiConfigSchema.optional(),
     human: humanConfigSchema.optional(),
+    component: componentConfigSchema.optional(),
 });
 export const graphConnectionSchema = z.object({
     from_port_id: z.uuid(),
@@ -228,15 +242,18 @@ export const saveGraphBodySchema = z
             else
                 outCount++;
         });
-        // end だけ「in は1つ以上」（複数ルートを別々の in で集約する）。
-        // start・他 kind は従来どおり1つ固定
-        if (node.kind === "end" ? inCount < 1 : inCount !== 1) {
+        // end は「in は1つ以上」（複数ルートを別々の in で集約する）。
+        // ai は2つ（上流データの in ＋ 差し戻しの instruction）。他 kind は1つ固定。
+        // key の妥当性は kindPortsViolation が別途見る
+        const expectIn = node.kind === "ai" ? 2 : 1;
+        const inCountOk = node.kind === "end" ? inCount >= 1 : inCount === expectIn;
+        if (!inCountOk) {
             ctx.addIssue({
                 code: "custom",
                 path: ["nodes", i, "ports"],
                 message: node.kind === "end"
                     ? "in ポートが1つ以上必要です"
-                    : "in ポートはちょうど1つ必要です",
+                    : `in ポートはちょうど${expectIn}つ必要です`,
             });
         }
         if (outCount < 1) {
@@ -266,6 +283,15 @@ export const saveGraphBodySchema = z
             }
             hookDirs.add(hook.hook_dir);
         });
+        // component は参照先が無いと成立しない（他 kind の設定はデフォルトで補えるが
+        // component_loop_id は補えない）
+        if (node.kind === "component" && node.component === undefined) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["nodes", i, "component"],
+                message: "component ノードには component_loop_id が必要です",
+            });
+        }
         // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）
         const violation = kindPortsViolation(node.kind, node.ports);
         if (violation) {
@@ -295,7 +321,7 @@ export const saveGraphBodySchema = z
     const usedPairs = new Set();
     graph.connections.forEach((conn, i) => {
         const from = portById.get(conn.from_port_id);
-        if (!from || from.io !== "out") {
+        if (from?.io !== "out") {
             ctx.addIssue({
                 code: "custom",
                 path: ["connections", i, "from_port_id"],
@@ -303,7 +329,7 @@ export const saveGraphBodySchema = z
             });
         }
         const to = portById.get(conn.to_port_id);
-        if (!to || to.io !== "in") {
+        if (to?.io !== "in") {
             ctx.addIssue({
                 code: "custom",
                 path: ["connections", i, "to_port_id"],
@@ -323,6 +349,29 @@ export const saveGraphBodySchema = z
     // 型の接続バリデーション（ポートのkind別仕様.md §接続バリデーション）。
     // 導出ポートは接続から型を解決した上で判定する。ai の in・wait の in は常に許可
     const resolved = resolvePortSchemas(graph.nodes, graph.connections);
+    // fan-in（同じ in ポートへの流入が2本以上）は同じ型でなければならない。
+    // 型が割れていると伝播が未宣言に落ちて下流の型チェックが効かなくなる
+    // （docs/tasks/wip/ポートスキーマのany撲滅.md）
+    const inboundByPort = new Map();
+    for (const conn of graph.connections) {
+        const list = inboundByPort.get(conn.to_port_id) ?? [];
+        list.push(conn.from_port_id);
+        inboundByPort.set(conn.to_port_id, list);
+    }
+    for (const [toPortId, fromPortIds] of inboundByPort) {
+        if (fromPortIds.length < 2)
+            continue;
+        const schemas = fromPortIds.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA);
+        if (!hasInboundConflict(schemas))
+            continue;
+        const to = portById.get(toPortId);
+        const toNode = nodeByPortId.get(toPortId);
+        ctx.addIssue({
+            code: "custom",
+            path: ["connections"],
+            message: `同じ入力ポート（${toNode?.name ?? "?"}.${to?.key ?? "?"}）に異なる型を接続できません`,
+        });
+    }
     graph.connections.forEach((conn, i) => {
         const from = portById.get(conn.from_port_id);
         const to = portById.get(conn.to_port_id);
@@ -345,21 +394,34 @@ export const saveGraphBodySchema = z
                 message: "終了ノードからは接続できません",
             });
         }
-        // human の reject の接続先は ai ノードのみ（kind 制約）
+        // human の reject の接続先は AI の instruction ポートのみ。
+        // 差し戻しは「元のセッションに指示を与える」操作で、上流データの口（in）とは
+        // 意味が違う（docs/tasks/wip/ポートスキーマのany撲滅.md）
         if (fromNode.kind === "human" &&
             from.key === "reject" &&
-            toNode.kind !== "ai") {
+            !(toNode.kind === "ai" && to.key === AI_INSTRUCTION_PORT_KEY)) {
             ctx.addIssue({
                 code: "custom",
                 path: ["connections", i, "to_port_id"],
-                message: "差し戻し（reject）の接続先は AI ノードのみです",
+                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）だけです",
             });
         }
         const fromSchema = resolved.get(conn.from_port_id) ?? from.schema;
         // human の in はどの型でも接続できる（上流が AI なら封筒 { data, description }、
         // それ以外は input 全体を data として表示する。型制約は課さない）
         // program の in への接続は 伝播型 ⊆ 宣言スキーマ。in は接続鏡映（sticky）なので
-        // 具体型の接続では自明に通り、接続元 any × 宣言維持のときだけ従来の意味を持つ
+        // 具体型の接続では自明に通り、接続元が未宣言 × 宣言維持のときだけ従来の意味を持つ
+        // （未宣言は unknown＝判断できないので通す。作りかけのグラフを保存できなくしない）
         const toSchema = resolved.get(conn.to_port_id) ?? to.schema;
         if (toNode.kind === "program" && !isSchemaSubset(fromSchema, toSchema)) {
             ctx.addIssue({
@@ -368,5 +430,14 @@ export const saveGraphBodySchema = z
                 message: "接続元の型が program の入力スキーマに適合しません（伝播型 ⊆ 宣言スキーマ）",
             });
         }
+        // component の in は子 loop の契約（焼き込み済み宣言）。program と同じ包含チェック
+        if (toNode.kind === "component" &&
+            !isSchemaSubset(fromSchema, toSchema)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["connections", i, "to_port_id"],
+                message: "接続元の型がコンポーネントの入力契約に適合しません（伝播型 ⊆ 契約）",
+            });
+        }
     });
 });

package/dist/_schemas/node.d.ts

@@ -7,6 +7,7 @@ export declare const nodeKindSchema: z.ZodEnum<{
     wait: "wait";
     start: "start";
     end: "end";
+    component: "component";
 }>;
 export type NodeKind = z.infer<typeof nodeKindSchema>;
 export declare const PORT_KEY_PATTERN: RegExp;

package/dist/_schemas/node.js

@@ -9,6 +9,9 @@ export const nodeKindSchema = z.enum([
     // docs/tasks/wip/開始・終了ノードの定義.md）
     "start",
     "end",
+    // コンポーネント（kind='component' の loop を配置して呼ぶ。子 run・戻り値あり。
+    // docs/tasks/wip/コンポーネント（ループの部品化と再利用）.md）
+    "component",
 ]);
 // ポート key（input/output 用の参照キー）の規則（db.md §2）。
 // name（ユーザーが見る表示名）は自由テキスト

package/dist/_schemas/port-spec.d.ts

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import type { GraphPort, JsonSchema } from "./node.js";
-export declare const ANY_SCHEMA: JsonSchema;
-export declare const isAnySchema: (schema: JsonSchema) => boolean;
+export declare const UNDECLARED_SCHEMA: JsonSchema;
+export declare const isUndeclaredSchema: (schema: JsonSchema) => boolean;
 export declare const FILE_SCHEMA_MARKER = "x-mawaru-type";
 export declare const FILE_SCHEMA_TYPE = "file";
 export declare const fileSchema: () => JsonSchema;
 export declare const isFileSchema: (schema: JsonSchema) => boolean;
+export declare const AI_INSTRUCTION_PORT_KEY = "instruction";
+export declare const instructionSchema: () => JsonSchema;
 export declare const LIST_COLUMN_TYPES: readonly ["string", "number", "boolean", "date"];
 export declare const listColumnTypeSchema: z.ZodEnum<{
     string: "string";
@@ -46,7 +48,11 @@ export declare const dataFormatOf: (schema: JsonSchema) => DataFormat | null;
 export declare const envelopeSchemaOf: (dataSchema: JsonSchema) => JsonSchema;
 export declare const envelopeDataSchemaOf: (schema: JsonSchema) => JsonSchema | null;
 export declare const isAiEnvelopeSchema: (schema: JsonSchema) => boolean;
+export declare const fixedInKeysOf: (kind: string) => string[] | null;
+export declare const manifestInKeysViolation: (kind: string, keys: string[]) => string | null;
 export declare const kindPortsViolation: (kind: string, ports: Pick<GraphPort, "io" | "key">[]) => string | null;
+export declare const mergeInboundSchemas: (schemas: JsonSchema[]) => JsonSchema;
+export declare const hasInboundConflict: (schemas: JsonSchema[]) => boolean;
 type PropagationNode = {
     id: string;
     kind: string;
@@ -58,5 +64,7 @@ type PortLink = {
 };
 export declare const resolvePortSchemas: <N extends PropagationNode>(nodes: N[], connections: PortLink[]) => Map<string, JsonSchema>;
 export declare const propagateDerivedPorts: <N extends PropagationNode>(nodes: N[], connections: PortLink[]) => N[];
+export type SchemaFit = "ok" | "mismatch" | "unknown";
+export declare const schemaFit: (sub: JsonSchema, sup: JsonSchema) => SchemaFit;
 export declare const isSchemaSubset: (sub: JsonSchema, sup: JsonSchema) => boolean;
 export {};

package/dist/_schemas/port-spec.js

@@ -2,14 +2,18 @@ import { z } from "zod";
 // ポートの kind 別型システム（docs/tasks/wip/ポートのkind別仕様.md）。
 // 型の決まり方は3分類：宣言（program / AI の in・out）／固定（human reject の
 // content 型）／導出（それ以外。接続元から伝播し、結果は ports.schema にキャッシュする）
-// content 型・未接続の導出ポートは any（{}）で表す。content の意味（エンジンが
-// content に変換して注入する口）はスキーマではなく kind が決める
-export const ANY_SCHEMA = {};
-export const isAnySchema = (schema) => Object.keys(schema).length === 0 || schema.type === undefined;
-// ---- file 型（AI ノードのファイル入力。docs/tasks/wip/AIノードのファイル入力（file型と添付）.md） ----
+// 「まだ型が決まっていない」＝未宣言を {} で表す（未接続・上流が未宣言・fan-in の型割れ）。
+// 「何でも受ける」型は存在しない：AI の in は接続元の具体型を鏡映し、差し戻しの指示は
+// instruction ポートの宣言型を持つ（docs/tasks/wip/ポートスキーマのany撲滅.md）
+export const UNDECLARED_SCHEMA = {};
+export const isUndeclaredSchema = (schema) => Object.keys(schema).length === 0 || schema.type === undefined;
+// ---- file 型（docs/tasks/done/AIノードのファイル入力（file型と添付）.md） ----
 // schema 上の file は x-mawaru-type マーカー付きの object（nominal に識別する）。値はバイト
-// ではなく storage path の参照（url は startAiStep の dispatch 時に発行して client_payload に
-// のみ載せる）。ajv は strict:false で未知キーワードを無視するので検証は素の JSON Schema のまま。
+// ではなく storage path の参照で、署名 URL はどこにも焼き込まない。
+// **file の位置は名前ではなくこのマーカーで決まる**：runner が宣言スキーマと値を並行走査して
+// 入力はワークスペースへ materialize（パスに置換）、出力はアップロード（参照に置換）する
+// （docs/tasks/wip/ポートスキーマ編集でファイル型を選べるようにする.md）。
+// ajv は strict:false で未知キーワードを無視するので検証は素の JSON Schema のまま。
 export const FILE_SCHEMA_MARKER = "x-mawaru-type";
 export const FILE_SCHEMA_TYPE = "file";
 export const fileSchema = () => ({
@@ -24,6 +28,25 @@ export const fileSchema = () => ({
     required: ["path", "name"],
 });
 export const isFileSchema = (schema) => schema[FILE_SCHEMA_MARKER] === FILE_SCHEMA_TYPE;
+// ---- 差し戻しの指示（AI の instruction ポート / human の reject ポート） ----
+// AI 入力の既存エンベロープ { prompt, files } と同じ形にする。配管が効く根拠は
+// files が file 型として宣言されていることであって、キー名ではない
+// （runner がマーカーで位置を見つけて materialize する）。
+// スクリーンショットを添えて差し戻すケースがあるので文章だけにしない
+// （docs/tasks/wip/ポートスキーマのany撲滅.md）
+export const AI_INSTRUCTION_PORT_KEY = "instruction";
+export const instructionSchema = () => ({
+    type: "object",
+    properties: {
+        prompt: { type: "string", description: "差し戻しの理由（AI への指示）" },
+        files: {
+            type: "array",
+            items: fileSchema(),
+            description: "スクリーンショットなどの参考資料",
+        },
+    },
+    required: ["prompt"],
+});
 // ---- データフォーマットカタログ ----
 // human 承認 UI の表示・編集フォームの出し分けに使う（テキスト＝string（markdown）／
 // リスト＝Array<Row>（列定義つき））。バリデーションには使わない（data は任意の型）
@@ -131,8 +154,34 @@ const FIXED_PORT_KEYS = {
     wait: { in: ["in"], out: ["main"] },
     // start は in 1つ（run 入力契約）＋ out main 1つの恒等パススルー
     start: { in: ["in"], out: ["main"] },
+    // component は in（子 loop の start.in 契約）＋ out main（end.out の戻り値）。
+    // スキーマは保存時にサーバが子 loop の契約から焼き込む宣言型
+    // （DERIVED/MIRROR には入れない＝接続で潰さない）
+    component: { in: ["in"], out: ["main"] },
 };
 const FREE_OUT_KINDS = new Set(["program", "ai"]);
+// out は自由（複数出口＝分岐）だが in の構成は固定。ai は上流データを受ける in と、
+// 差し戻しの指示を受ける instruction の2口（意味の違う入力を1つのポートに
+// fan-in させない。docs/tasks/wip/ポートスキーマのany撲滅.md）
+const FIXED_IN_KEYS = {
+    program: ["in"],
+    ai: ["in", AI_INSTRUCTION_PORT_KEY],
+};
+export const fixedInKeysOf = (kind) => FIXED_IN_KEYS[kind] ?? null;
+// config.json（manifest）の inputs 検査（適合なら null）。同じルールを二重に持たないため
+// manifest 側はここを参照する（docs/tasks/wip/manifestのin複数対応（instructionポート）.md）。
+// **必須は "in" だけ**で、kind が固定する他の in（ai の instruction）は任意：スキーマは
+// constSchemaOf が焼き込む固定型なのでエディタ側で補え、in を2口に分ける前に同期された
+// config.json もそのまま読める
+export const manifestInKeysViolation = (kind, keys) => {
+    const allowed = fixedInKeysOf(kind) ?? ["in"];
+    if (!keys.includes("in"))
+        return 'inputs は "in" を宣言してください';
+    const unknown = keys.filter((key) => !allowed.includes(key));
+    return unknown.length > 0
+        ? `inputs に宣言できない key があります: ${unknown.join(" / ")}（${allowed.join(" / ")} のみ）`
+        : null;
+};
 // kind 別のポート構成違反を返す（適合なら null）。in=1/out>=1 の構造ルールは
 // graph.ts 側の既存チェックが担い、ここは key の固定だけ見る
 export const kindPortsViolation = (kind, ports) => {
@@ -150,10 +199,17 @@ export const kindPortsViolation = (kind, ports) => {
     }
     const fixed = FIXED_PORT_KEYS[kind];
     if (!fixed) {
-        // program / ai（自由 out）：in の key だけ "in" 固定
-        if (FREE_OUT_KINDS.has(kind) &&
-            ports.some((p) => p.io === "in" && p.key !== "in"))
-            return `${kind} の in ポートの key は "in" です`;
+        // program / ai（自由 out）：in の構成だけ固定
+        const expectIn = FIXED_IN_KEYS[kind];
+        if (FREE_OUT_KINDS.has(kind) && expectIn) {
+            const inKeys = ports
+                .filter((p) => p.io === "in")
+                .map((p) => p.key)
+                .sort();
+            if (inKeys.join(",") !== [...expectIn].sort().join(",")) {
+                return `${kind} の in ポートは ${expectIn.join(" / ")} です`;
+            }
+        }
         return null;
     }
     const keysOf = (io) => ports
@@ -167,8 +223,32 @@ export const kindPortsViolation = (kind, ports) => {
     }
     return null;
 };
-// end も導出ノード（各 in は上流から、out main は any）。個別処理は
-// resolvePortSchemas 内で行うが、初期スキーマを any にするためここに含める。
+// ---- 型伝播（導出ポートの解決） ----
+// 接続の両端は同じスキーマになる（値入力フォームのSchemaForm統一.md）。
+// wait / human は素通し（パラメトリック）ノード：in は接続元の out、out は in と同型。
+// 例外は human の approve：接続元が AI ノードのときだけ封筒を剥がして data 型になる。
+// human の reject は未宣言のまま（段階2 で instruction エンベロープを宣言する）。
+// 宣言 out（program / ai）は触らない。
+// program / ai の in は接続鏡映（sticky）：接続元 out が具体型のときだけ上書きし、
+// 未接続・型割れ・未宣言は現スキーマ（宣言）を維持する（鏡映結果は repo の config.json
+// へも書き戻される。docs/tasks/wip/ポート編集のrepo書き戻し同期.md）
+// 複数の流入（fan-in）から型を1つに決める：未宣言を除いて具体型が1種類ならその型、
+// 0種類なら未宣言。2種類以上は型が割れているので未宣言に落とす
+// （保存時に graph.ts が 422 で弾く。伝播は止めずに固定点へ収束させる）
+export const mergeInboundSchemas = (schemas) => {
+    const uniq = [
+        ...new Set(schemas
+            .filter((s) => !isUndeclaredSchema(s))
+            .map((s) => JSON.stringify(s))),
+    ];
+    return uniq.length === 1 && uniq[0] !== undefined
+        ? JSON.parse(uniq[0])
+        : UNDECLARED_SCHEMA;
+};
+// 流入の具体型が2種類以上あるか（＝同じポートに違う型を流し込んでいる）
+export const hasInboundConflict = (schemas) => new Set(schemas.filter((s) => !isUndeclaredSchema(s)).map((s) => JSON.stringify(s))).size > 1;
+// end も導出ノード（各 in は上流から、out main は未宣言）。個別処理は
+// resolvePortSchemas 内で行うが、初期スキーマを未宣言にするためここに含める。
 // start も導出ノード：out main は接続先の in から逆向きに転写し、in は out と同型
 // （run 入力契約＝接続先の入力宣言。開始ノードの入力契約を接続先から導出.md）
 const DERIVED_KINDS = new Set(["wait", "human", "end", "start"]);
@@ -179,18 +259,30 @@ const isDerivedPort = (kind, port) => DERIVED_KINDS.has(kind) &&
 // AI の in は nodes/ai/<dir>/config.json の inputs.in 由来の宣言型が初期値で、
 // 接続時は program と同じ鏡映で接続元と同値に同期される（const 扱い廃止。
 // 接続バリデーションの「ai の in は常に許可」は維持）
-const isConstPort = (kind, port) => kind === "human" && port.io === "out" && port.key === "reject";
+// 宣言型で固定されるポート（導出も鏡映もしない）。差し戻しの指示エンベロープを
+// human の出口と AI の入口の両方に焼き込むことで、両端が同じ具体型で一致する
+const constSchemaOf = (kind, port) => {
+    if (kind === "human" && port.io === "out" && port.key === "reject") {
+        return instructionSchema();
+    }
+    if (kind === "ai" &&
+        port.io === "in" &&
+        port.key === AI_INSTRUCTION_PORT_KEY) {
+        return instructionSchema();
+    }
+    return null;
+};
 // port_id → 解決済みスキーマ。導出は接続を遡って固定点まで反復し、
-// 未接続・複数流入・純パラメトリック閉路は any に落とす（MVP の割り切り）
+// 未接続・純パラメトリック閉路・fan-in の型割れは未宣言に落とす
 export const resolvePortSchemas = (nodes, connections) => {
     const resolved = new Map();
     const kindByPortId = new Map();
     for (const node of nodes) {
         for (const port of node.ports) {
             kindByPortId.set(port.id, node.kind);
-            resolved.set(port.id, isDerivedPort(node.kind, port) || isConstPort(node.kind, port)
-                ? ANY_SCHEMA
-                : port.schema);
+            const constSchema = constSchemaOf(node.kind, port);
+            resolved.set(port.id, constSchema ??
+                (isDerivedPort(node.kind, port) ? UNDECLARED_SCHEMA : port.schema));
         }
     }
     // in ポートへの流入（差し戻しの fan-in があり得る。1本のときだけ型を採用）
@@ -215,52 +307,42 @@ export const resolvePortSchemas = (nodes, connections) => {
                 }
             };
             // start：out main は接続先 in の解決値を転写（逆向き導出）。fan-out は
-            // 非 any が1種類（JSON 等値）のときだけ採用し、未接続・型割れは any。
+            // 非未宣言が1種類（JSON 等値）のときだけ採用し、未接続・型割れは未宣言。
             // in は out main と同型（恒等の向きを out→in に逆転。run 入力契約は
             // 接続先の入力宣言から自動で決まる）
             if (node.kind === "start") {
                 const inPort = node.ports.find((p) => p.io === "in");
                 const outMain = node.ports.find((p) => p.io === "out" && p.key === "main");
                 if (inPort && outMain) {
-                    const targets = (outbound.get(outMain.id) ?? [])
-                        .map((id) => resolved.get(id) ?? ANY_SCHEMA)
-                        .filter((s) => !isAnySchema(s))
-                        .map((s) => JSON.stringify(s));
-                    const uniq = [...new Set(targets)];
-                    const schema = uniq.length === 1 && uniq[0] !== undefined
-                        ? JSON.parse(uniq[0])
-                        : ANY_SCHEMA;
+                    const schema = mergeInboundSchemas((outbound.get(outMain.id) ?? []).map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA));
                     assign(outMain.id, schema);
                     assign(inPort.id, schema);
                 }
                 continue;
             }
             // end：各 in を自分の単一上流から導出（複数ルートを別 in で集約）。
-            // out main は any 固定（ルートごとに型が違いうる。Loop-in-Loop で詰める）
+            // out main は未宣言固定（ルートごとに型が違いうる。Loop-in-Loop で詰める）
             if (node.kind === "end") {
                 for (const port of node.ports) {
                     if (port.io !== "in")
                         continue;
                     const srcs = inbound.get(port.id) ?? [];
-                    assign(port.id, srcs.length === 1 && srcs[0] !== undefined
-                        ? (resolved.get(srcs[0]) ?? ANY_SCHEMA)
-                        : ANY_SCHEMA);
+                    assign(port.id, mergeInboundSchemas(srcs.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA)));
                 }
                 continue;
             }
             const isMirror = MIRROR_KINDS.has(node.kind);
             if (!DERIVED_KINDS.has(node.kind) && !isMirror)
                 continue;
-            const inPort = node.ports.find((p) => p.io === "in");
+            // ai は in が2口あるので、上流データの口（key="in"）だけを鏡映・導出の対象にする
+            const inPort = node.ports.find((p) => p.io === "in" && p.key === "in");
             if (!inPort)
                 continue;
             const sources = inbound.get(inPort.id) ?? [];
-            const inSchema = sources.length === 1 && sources[0] !== undefined
-                ? (resolved.get(sources[0]) ?? ANY_SCHEMA)
-                : ANY_SCHEMA;
-            // 鏡映（program）は具体型が流れてきたときだけ上書き（宣言を any で潰さない）
+            const inSchema = mergeInboundSchemas(sources.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA));
+            // 鏡映（program / ai）は具体型が流れてきたときだけ上書き（宣言を未宣言で潰さない）
             if (isMirror) {
-                if (!isAnySchema(inSchema))
+                if (!isUndeclaredSchema(inSchema))
                     assign(inPort.id, inSchema);
                 continue;
             }
@@ -273,7 +355,7 @@ export const resolvePortSchemas = (nodes, connections) => {
             for (const port of node.ports) {
                 if (port.io === "out" && isDerivedPort(node.kind, port)) {
                     assign(port.id, node.kind === "human" && port.key === "approve" && fromAiNode
-                        ? (envelopeDataSchemaOf(inSchema) ?? ANY_SCHEMA)
+                        ? (envelopeDataSchemaOf(inSchema) ?? UNDECLARED_SCHEMA)
                         : inSchema);
                 }
             }
@@ -299,18 +381,15 @@ export const propagateDerivedPorts = (nodes, connections) => {
         return touched ? { ...node, ports } : node;
     });
 };
-// ---- 接続バリデーション（伝播型 ⊆ 宣言スキーマ） ----
-// 完全な JSON Schema 包含ではなく実用的な構造チェック：any は素通し、type 一致、
-// object は宣言側 required の存在と型互換、array は items 互換
-export const isSchemaSubset = (sub, sup) => {
-    if (isAnySchema(sup) || isAnySchema(sub))
-        return true;
-    // file は nominal：マーカー一致の file 同士だけ可（file → any は上の any 判定で許可）。
+export const schemaFit = (sub, sup) => {
+    if (isUndeclaredSchema(sup) || isUndeclaredSchema(sub))
+        return "unknown";
+    // file は nominal：マーカー一致の file 同士だけ可。
     // 構造が同じだけの普通の object は file に繋がない／file は普通の object に繋がない
     if (isFileSchema(sub) || isFileSchema(sup))
-        return isFileSchema(sub) && isFileSchema(sup);
+        return isFileSchema(sub) && isFileSchema(sup) ? "ok" : "mismatch";
     if (sub.type !== sup.type)
-        return false;
+        return "mismatch";
     if (sup.type === "object") {
         const subProps = (sub.properties ?? {});
         const subRequired = (sub.required ?? []);
@@ -318,19 +397,22 @@ export const isSchemaSubset = (sub, sup) => {
         for (const key of (sup.required ?? [])) {
             const subProp = subProps[key];
             if (!subProp || !subRequired.includes(key))
-                return false;
+                return "mismatch";
             const supProp = supProps[key];
-            if (supProp && !isSchemaSubset(subProp, supProp))
-                return false;
+            // ネストは「不適合でなければよい」（未宣言のプロパティで親を落とさない）
+            if (supProp && schemaFit(subProp, supProp) === "mismatch")
+                return "mismatch";
         }
-        return true;
+        return "ok";
     }
     if (sup.type === "array") {
         const supItems = sup.items;
         const subItems = sub.items;
         if (!supItems || !subItems)
-            return true;
-        return isSchemaSubset(subItems, supItems);
+            return "ok";
+        return schemaFit(subItems, supItems) === "mismatch" ? "mismatch" : "ok";
     }
-    return true;
+    return "ok";
 };
+// 保存時の接続チェック用：判断できない（未宣言）ものは通す
+export const isSchemaSubset = (sub, sup) => schemaFit(sub, sup) !== "mismatch";