@mawaru/sdk 0.13.0 → 0.14.1

package/_schemas/port-spec.ts

@@ -2,12 +2,14 @@ import { z } from "zod"
 import type { GraphPort, JsonSchema, PortIo } from "./node.js"
 
 // ポートの kind 別型システム（docs/tasks/wip/ポートのkind別仕様.md）。
-// 型の決まり方は3分類：宣言（program / AI の in・out）／固定（human reject の
-// content 型）／導出（それ以外。接続元から伝播し、結果は ports.schema にキャッシュする）
+// 型の決まり方は2分類：宣言（program / ai の in・out。human はビューの宣言を転写）／
+// 導出（それ以外。接続元から伝播し、結果は ports.schema にキャッシュする）。
+// mawaru がコードで型を固定するポートは無い
+// （docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md）
 
 // 「まだ型が決まっていない」＝未宣言を {} で表す（未接続・上流が未宣言・fan-in の型割れ）。
-// 「何でも受ける」型は存在しない：AI の in は接続元の具体型を鏡映し、差し戻しの指示は
-// instruction ポートの宣言型を持つ（docs/tasks/wip/ポートスキーマのany撲滅.md）
+// 「何でも受ける」型は存在しない：program / ai の in は接続元の具体型を鏡映する
+// （docs/tasks/wip/ポートスキーマのany撲滅.md）
 export const UNDECLARED_SCHEMA: JsonSchema = {}
 
 export const isUndeclaredSchema = (schema: JsonSchema): boolean =>
@@ -38,14 +40,12 @@ export const fileSchema = (): JsonSchema => ({
 export const isFileSchema = (schema: JsonSchema): boolean =>
   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"
-
+// ---- 差し戻しの指示のデフォルト型 ----
+// 雛形（エディタの既定ポート・ais/create）と承認ビューの既定宣言が参照する
+// **デフォルトであって強制ではない**：ユーザーはポートの宣言を自由に変えられ、
+// 接続の成立は通常の型検証だけが決める。配管が効く根拠は files が file 型として
+// 宣言されていることであって、キー名ではない（runner がマーカーで位置を見つけて
+// materialize する）。スクリーンショットを添えて差し戻すケースがあるので文章だけにしない
 export const instructionSchema = (): JsonSchema => ({
   type: "object",
   properties: {
@@ -138,38 +138,6 @@ export const dataFormatOf = (schema: JsonSchema): DataFormat | null => {
   return { format: "list", columns }
 }
 
-// 封筒型 { data: T, description: string }。T は任意の JSON Schema、description は
-// AI によるデータの説明（AI が必ず生成する）。AI の全出口に強制する
-export const envelopeSchemaOf = (dataSchema: JsonSchema): JsonSchema => ({
-  type: "object",
-  properties: {
-    data: dataSchema,
-    description: { type: "string" },
-  },
-  required: ["data", "description"],
-})
-
-// 封筒型なら data のサブスキーマを返す（data キー必須の object。それ以外は null）
-export const envelopeDataSchemaOf = (schema: JsonSchema): JsonSchema | null => {
-  if (schema.type !== "object") return null
-  const properties = (schema.properties ?? {}) as Record<string, JsonSchema>
-  const required = (schema.required ?? []) as string[]
-  const data = properties.data
-  if (!data || !required.includes("data")) return null
-  return data
-}
-
-// AI の出口として妥当な封筒型か：data と description: string の両方が必須
-export const isAiEnvelopeSchema = (schema: JsonSchema): boolean => {
-  if (envelopeDataSchemaOf(schema) === null) return false
-  const properties = (schema.properties ?? {}) as Record<string, JsonSchema>
-  const required = (schema.required ?? []) as string[]
-  return (
-    properties.description?.type === "string" &&
-    required.includes("description")
-  )
-}
-
 // ---- kind 別ポート構成 ----
 // human / wait は構成（数・key・io）が固定。program / ai は in 1つ＋out 1つ以上
 // （key 自由。複数 out＝分岐。AIノードの複数出口（分岐）.md）
@@ -187,22 +155,19 @@ const FIXED_PORT_KEYS: Record<string, { in: string[]; out: string[] }> = {
 
 const FREE_OUT_KINDS = new Set(["program", "ai"])
 
-// out は自由（複数出口＝分岐）だが in の構成は固定。ai は上流データを受ける in と、
-// 差し戻しの指示を受ける instruction の2口（意味の違う入力を1つのポートに
-// fan-in させない。docs/tasks/wip/ポートスキーマのany撲滅.md）
+// out は自由（複数出口＝分岐）。program は in の構成も固定（1口）だが、
+// ai は in も自由（追加・削除・key 自由。セッション再開は key ではなくポートの
+// resume 属性で決まる。ポート型固定の撤去とセッション再開のポート属性化.md）
 const FIXED_IN_KEYS: Record<string, string[]> = {
   program: ["in"],
-  ai: ["in", AI_INSTRUCTION_PORT_KEY],
 }
 
 export const fixedInKeysOf = (kind: string): string[] | null =>
   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 もそのまま読める
+// manifest 側はここを参照する。in の構成が固定の kind（program）だけが使う
+// （ai の inputs は key 自由なので ai-manifest 側で件数と key の規則だけ見る）
 export const manifestInKeysViolation = (
   kind: string,
   keys: string[],
@@ -265,13 +230,12 @@ export const kindPortsViolation = (
 
 // ---- 型伝播（導出ポートの解決） ----
 // 接続の両端は同じスキーマになる（値入力フォームのSchemaForm統一.md）。
-// wait / human は素通し（パラメトリック）ノード：in は接続元の out、out は in と同型。
-// 例外は human の approve：接続元が AI ノードのときだけ封筒を剥がして data 型になる。
-// human の reject は未宣言のまま（段階2 で instruction エンベロープを宣言する）。
+// wait は素通し（パラメトリック）ノード：in は接続元の out、out は in と同型。
+// human はビューの宣言を転写（"T" は素通しと同じ挙動。reject もビューの宣言）。
 // 宣言 out（program / ai）は触らない。
-// program / ai の in は接続鏡映（sticky）：接続元 out が具体型のときだけ上書きし、
-// 未接続・型割れ・未宣言は現スキーマ（宣言）を維持する（鏡映結果は repo の config.json
-// へも書き戻される。docs/tasks/wip/ポート編集のrepo書き戻し同期.md）
+// program / ai の in は**全ての口が**接続鏡映（sticky）：接続元 out が具体型のときだけ
+// 上書きし、未接続・型割れ・未宣言は現スキーマ（宣言）を維持する（鏡映結果は repo の
+// config.json へも書き戻される。docs/tasks/wip/ポート編集のrepo書き戻し同期.md）
 
 // 複数の流入（fan-in）から型を1つに決める：未宣言を除いて具体型が1種類ならその型、
 // 0種類なら未宣言。2種類以上は型が割れているので未宣言に落とす
@@ -311,13 +275,19 @@ export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA
 
 // 伝播のオプション。sdk は承認ビューのカタログを知らない（非公開。企業向けビューの
 // キーが npm 公開物に載るのを避ける）ので、呼び出し元が解決して渡す
-// → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
+// → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
 export type PropagationOptions<N> = {
-  // human の in / approve に転写する型（承認ビューの宣言）。null / undefined なら
-  // その node は対象外（human 以外）。上流ノードの kind は一切見ない
-  viewPortSchemasOf?: (
-    node: N,
-  ) => { in: DeclaredPortSchema; out: DeclaredPortSchema } | null | undefined
+  // 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 は未宣言）。個別処理は
@@ -331,32 +301,16 @@ const MIRROR_KINDS = new Set(["program", "ai"])
 
 const isDerivedPort = (kind: string, port: Pick<GraphPort, "io" | "key">) =>
   DERIVED_KINDS.has(kind) &&
-  (port.io === "in" || port.key === "main" || port.key === "approve")
-
-// AI の in は nodes/ai/<dir>/config.json の inputs.in 由来の宣言型が初期値で、
-// 接続時は program と同じ鏡映で接続元と同値に同期される（const 扱い廃止。
-// 接続バリデーションの「ai の in は常に許可」は維持）
-// 宣言型で固定されるポート（導出も鏡映もしない）。差し戻しの指示エンベロープを
-// human の出口と AI の入口の両方に焼き込むことで、両端が同じ具体型で一致する
-const constSchemaOf = (
-  kind: string,
-  port: Pick<GraphPort, "io" | "key">,
-): JsonSchema | null => {
-  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.io === "in" ||
+    port.key === "main" ||
+    port.key === "approve" ||
+    port.key === "reject")
 
 // port_id → 解決済みスキーマ。導出は接続を遡って固定点まで反復し、
-// 未接続・純パラメトリック閉路・fan-in の型割れは未宣言に落とす
+// 未接続・純パラメトリック閉路・fan-in の型割れは未宣言に落とす。
+// ai の in は nodes/ai/<dir>/config.json の inputs[key].schema 由来の宣言型が初期値で、
+// 接続時は program と同じ鏡映で接続元と同値に同期される（どの in も対等。
+// instruction への型の焼き込みは廃止）
 export const resolvePortSchemas = <N extends PropagationNode>(
   nodes: N[],
   connections: PortLink[],
@@ -367,11 +321,9 @@ export const resolvePortSchemas = <N extends PropagationNode>(
   for (const node of nodes) {
     for (const port of node.ports) {
       kindByPortId.set(port.id, node.kind)
-      const constSchema = constSchemaOf(node.kind, port)
       resolved.set(
         port.id,
-        constSchema ??
-          (isDerivedPort(node.kind, port) ? UNDECLARED_SCHEMA : port.schema),
+        isDerivedPort(node.kind, port) ? UNDECLARED_SCHEMA : port.schema,
       )
     }
   }
@@ -434,20 +386,29 @@ export const resolvePortSchemas = <N extends PropagationNode>(
       }
       const isMirror = MIRROR_KINDS.has(node.kind)
       if (!DERIVED_KINDS.has(node.kind) && !isMirror) continue
-      // ai は in が2口あるので、上流データの口（key="in"）だけを鏡映・導出の対象にする
-      const inPort = node.ports.find((p) => p.io === "in" && p.key === "in")
+      // 鏡映（program / ai）：全ての in が対象。具体型が流れてきたときだけ上書きする
+      // （宣言を未宣言で潰さない）。ai の in はどの口も対等（instruction の特別扱いは無い）
+      if (isMirror) {
+        for (const port of node.ports) {
+          if (port.io !== "in") continue
+          const sources = inbound.get(port.id) ?? []
+          const inSchema = mergeInboundSchemas(
+            sources.map((id) => resolved.get(id) ?? UNDECLARED_SCHEMA),
+          )
+          if (!isUndeclaredSchema(inSchema)) assign(port.id, inSchema)
+        }
+        continue
+      }
+      // 導出（wait / human）：in は上流から
+      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),
       )
-      // 鏡映（program / ai）は具体型が流れてきたときだけ上書き（宣言を未宣言で潰さない）
-      if (isMirror) {
-        if (!isUndeclaredSchema(inSchema)) assign(inPort.id, inSchema)
-        continue
-      }
       // 承認ビューの宣言を human のポートへそのまま転写する（上流ノードの kind は見ない）。
-      // "T" は「上流の out をコピー」（in）／「in と同型」（approve）。
+      // "T" は「上流の out をコピー」（in）／「in と同型」（approve）。reject は具体型の宣言
+      // のみで、宣言が無ければ未宣言のまま（mawaru が型を焼き込むことはしない）。
       // 上流の out は書き換えない：逆伝播すると fan-out 先のビューが食い違ったとき
       // 型割れが config.json へ write-through され、元の出力宣言を黙って壊す。
       // ズレは接続の型エラーで見せてユーザーの [修正する] で直す
@@ -458,14 +419,17 @@ export const resolvePortSchemas = <N extends PropagationNode>(
           : inSchema
       assign(inPort.id, effectiveIn)
       for (const port of node.ports) {
-        if (port.io === "out" && isDerivedPort(node.kind, port)) {
-          assign(
-            port.id,
-            declared && declared.out !== COPY_UPSTREAM_SCHEMA
-              ? declared.out
-              : effectiveIn,
-          )
+        if (port.io !== "out" || !isDerivedPort(node.kind, port)) continue
+        if (node.kind === "human" && port.key === "reject") {
+          if (declared) assign(port.id, declared.reject)
+          continue
         }
+        assign(
+          port.id,
+          declared && declared.approve !== COPY_UPSTREAM_SCHEMA
+            ? declared.approve
+            : effectiveIn,
+        )
       }
     }
     if (!changed) break

package/dist/_schemas/ai-manifest.d.ts

@@ -8,6 +8,11 @@ export declare const aiModelSchema: z.ZodEnum<{
 }>;
 export type AiModel = z.infer<typeof aiModelSchema>;
 export declare const DEFAULT_AI_MODEL = "claude-opus-5";
+export declare const aiInputDeclSchema: z.ZodObject<{
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    resume: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AiInputDecl = z.infer<typeof aiInputDeclSchema>;
 export declare const aiManifestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
@@ -21,7 +26,13 @@ export declare const aiManifestSchema: z.ZodObject<{
     skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
     env: z.ZodDefault<z.ZodArray<z.ZodString>>;
     verbose: z.ZodOptional<z.ZodBoolean>;
-    inputs: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    inputs: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        resume: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodTransform<{
+        schema: Record<string, unknown>;
+        resume?: boolean | undefined;
+    }, Record<string, unknown>>>]>>;
     outputs: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export type AiManifest = z.infer<typeof aiManifestSchema>;

package/dist/_schemas/ai-manifest.js

@@ -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" 等）は採らずバージョンを固定する：実行のたびに黙って別モデルへ
 // 乗り換わると品質も費用も再現しないため。新モデルが出たらこの配列を足して SDK を publish する
@@ -12,6 +11,20 @@ export const AI_MODELS = [
 ];
 export const aiModelSchema = z.enum(AI_MODELS);
 export const DEFAULT_AI_MODEL = "claude-opus-5";
+// 入力口の宣言：スキーマ＋実行属性。resume: true の口から入力が届いた実行は
+// 同じノードの直近セッションを復元して再開する（backend が ports.resume へ同期して
+// payload 発行時に参照する。ポート型固定の撤去とセッション再開のポート属性化.md）
+export const aiInputDeclSchema = z.object({
+    schema: jsonSchemaSchema,
+    resume: z.boolean().optional(),
+});
+// 旧形式（値が素の JSON Schema）は { schema: 値 } として読む。判別は「schema キーを
+// 持つか」：JSON Schema のトップレベルに "schema" キーは現れない（メタスキーマ参照は
+// "$schema"）ので実用上一意。書き戻し（backend の syncNodeConfigs）は常に新形式で書く
+const aiInputValueSchema = z.union([
+    aiInputDeclSchema,
+    jsonSchemaSchema.transform((schema) => ({ schema })),
+]);
 // nodes/ai/<dir>/config.json（実行repoの構造見直し）。AI ノードの定義（prompt/model/skills/
 // 入出力スキーマ/env）は repo 側が正で、エディタが取り込んで ports を自動生成する
 // （実行時の正は ports テーブルのまま。プログラム規約 v2 と同じ関係）。
@@ -34,34 +47,36 @@ 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件以上宣言してください",
+        });
+    }
 });

package/dist/_schemas/extract-component.js

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

package/dist/_schemas/graph.d.ts

@@ -67,6 +67,7 @@ export declare const humanConfigSchema: z.ZodObject<{
 export type HumanConfig = z.infer<typeof humanConfigSchema>;
 export declare const componentConfigSchema: z.ZodObject<{
     component_loop_id: z.ZodUUID;
+    refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export type ComponentConfig = z.infer<typeof componentConfigSchema>;
 export declare const graphNodeHookSchema: z.ZodObject<{
@@ -98,6 +99,7 @@ export declare const graphNodeSchema: z.ZodObject<{
         key: z.ZodString;
         name: z.ZodString;
         schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        resume: z.ZodOptional<z.ZodBoolean>;
         side: z.ZodOptional<z.ZodEnum<{
             top: "top";
             right: "right";
@@ -149,6 +151,7 @@ export declare const graphNodeSchema: z.ZodObject<{
     }, z.core.$strip>>;
     component: z.ZodOptional<z.ZodObject<{
         component_loop_id: z.ZodUUID;
+        refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type GraphNode = z.infer<typeof graphNodeSchema>;
@@ -179,6 +182,7 @@ export declare const saveGraphBodySchema: z.ZodObject<{
             key: z.ZodString;
             name: z.ZodString;
             schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            resume: z.ZodOptional<z.ZodBoolean>;
             side: z.ZodOptional<z.ZodEnum<{
                 top: "top";
                 right: "right";
@@ -230,6 +234,7 @@ export declare const saveGraphBodySchema: z.ZodObject<{
         }, z.core.$strip>>;
         component: z.ZodOptional<z.ZodObject<{
             component_loop_id: z.ZodUUID;
+            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     connections: z.ZodArray<z.ZodObject<{

package/dist/_schemas/graph.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { graphPortSchema, jsonSchemaSchema, nodeKindSchema, portKeySchema, } from "./node.js";
-import { AI_INSTRUCTION_PORT_KEY, hasInboundConflict, isAiEnvelopeSchema, isSchemaSubset, kindPortsViolation, resolvePortSchemas, UNDECLARED_SCHEMA, } from "./port-spec.js";
+import { hasInboundConflict, isSchemaSubset, kindPortsViolation, resolvePortSchemas, UNDECLARED_SCHEMA, } from "./port-spec.js";
 // refs＝ループ変数の袋（key→任意の JSON 値。上流出力の参照（refs）.md）。
 // run 開始時に定義から複製され、全 step に全量差し込まれる。
 // key はポート key と同じ規則（^[a-z][a-z0-9_]*$）。実行系ボディ
@@ -156,6 +156,10 @@ export const humanConfigSchema = z.object({
 // （docs/tasks/wip/コンポーネント（ループの部品化と再利用）.md）
 export const componentConfigSchema = z.object({
     component_loop_id: z.uuid(),
+    // 配置の設定値：子 loop の refs 定義（default/required）への上書き。
+    // 子 run 起動時の起動時指定として渡る（省略＝上書きなし。検証は保存 API と
+    // 起動時の mergeRefs が行う。コンポーネントの設定値（refs）と1ノードのコンポーネント化.md）
+    refs: z.record(z.string(), z.unknown()).optional(),
 });
 // ノードにアタッチされた IOHook（node_hooks に対応。アタッチできるのは program ノードのみ）。
 // on_input / on_output / on_signal はアタッチ時に repo の config.json（hookManifestSchema）から
@@ -256,17 +260,16 @@ export const saveGraphBodySchema = z
                 outCount++;
         });
         // end は「in は1つ以上」（複数ルートを別々の in で集約する）。
-        // ai は2つ（上流データの in ＋ 差し戻しの instruction）。他 kind は1つ固定。
+        // ai も1つ以上（in は自由ポート：追加・削除・key 自由）。他 kind は1つ固定。
         // key の妥当性は kindPortsViolation が別途見る
-        const expectIn = node.kind === "ai" ? 2 : 1;
-        const inCountOk = node.kind === "end" ? inCount >= 1 : inCount === expectIn;
+        const inCountOk = node.kind === "end" || node.kind === "ai" ? inCount >= 1 : inCount === 1;
         if (!inCountOk) {
             ctx.addIssue({
                 code: "custom",
                 path: ["nodes", i, "ports"],
-                message: node.kind === "end"
+                message: node.kind === "end" || node.kind === "ai"
                     ? "in ポートが1つ以上必要です"
-                    : `in ポートはちょうど${expectIn}つ必要です`,
+                    : "in ポートはちょうど1つ必要です",
             });
         }
         if (outCount < 1) {
@@ -305,7 +308,8 @@ export const saveGraphBodySchema = z
                 message: "component ノードには component_loop_id が必要です",
             });
         }
-        // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）
+        // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）。
+        // ポートのスキーマ自体は kind によらず任意の JSON Schema（形の強制はしない）
         const violation = kindPortsViolation(node.kind, node.ports);
         if (violation) {
             ctx.addIssue({
@@ -314,19 +318,6 @@ export const saveGraphBodySchema = z
                 message: violation,
             });
         }
-        // AI の出力宣言は封筒型 { data: T, description: string }（T は任意の JSON Schema）。
-        // 複数出口でも全出口に強制する（どの出口も human に接続できる不変条件）
-        if (node.kind === "ai") {
-            node.ports.forEach((port, j) => {
-                if (port.io === "out" && !isAiEnvelopeSchema(port.schema)) {
-                    ctx.addIssue({
-                        code: "custom",
-                        path: ["nodes", i, "ports", j],
-                        message: "AI の出力は封筒型 { data, description } で宣言してください",
-                    });
-                }
-            });
-        }
     });
     // 接続：両端がグラフ内の port を指し、from=out / to=in。
     // 同じ out ポートから複数の in への fan-out は許す（並行分岐）。
@@ -407,16 +398,14 @@ export const saveGraphBodySchema = z
                 message: "終了ノードからは接続できません",
             });
         }
-        // 差し戻し（reject）と instruction の組み合わせは kind で縛らない：両端とも
-        // instructionSchema()（{ prompt, files }）で型が固定されているので、下の型検証だけで
-        // 「型が合う口にしか繋がらない」が成立する。差し戻し先が AI である必要はない
-        // （{ prompt, files } を受ける program へも繋げる）
+        // 差し戻し（reject）と instruction の組み合わせに kind の縛りも型固定も無い：
+        // reject の型はビューの宣言、instruction は ai の in の1つ（接続鏡映）でしかない
+        // → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
         // 型検証は kind によらず常に 伝播型（out） ⊆ 伝播型（in）。
         // 未宣言は unknown＝判断できないので通す（作りかけのグラフを保存できなくしない）。
         // 接続鏡映する口（program / ai の in）とコピー宣言のビューは接続元の型を採用する
         // ので自明に通り、実質の検証対象は宣言で固定された口
-        // （component の契約・ai の instruction・宣言のあるビューの human.in）になる
-        // → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
+        // （component の契約・宣言のあるビューの human.in）になる
         const fromSchema = resolved.get(conn.from_port_id) ?? from.schema;
         const toSchema = resolved.get(conn.to_port_id) ?? to.schema;
         if (!isSchemaSubset(fromSchema, toSchema)) {

package/dist/_schemas/node.d.ts

@@ -37,6 +37,7 @@ export declare const graphPortSchema: z.ZodObject<{
     key: z.ZodString;
     name: z.ZodString;
     schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    resume: z.ZodOptional<z.ZodBoolean>;
     side: z.ZodOptional<z.ZodEnum<{
         top: "top";
         right: "right";

package/dist/_schemas/node.js

@@ -36,6 +36,10 @@ export const graphPortSchema = z
     key: portKeySchema,
     name: z.string().min(1),
     schema: jsonSchemaSchema,
+    // in ポートの実行属性：true ならこの口から届いた実行は前回セッションを復元して
+    // 再開する（AI ノードで意味を持つ。key ではなくこの属性が再開を決める。
+    // ポート型固定の撤去とセッション再開のポート属性化.md）
+    resume: z.boolean().optional(),
     side: portSideSchema.optional(),
     offset: z.number().min(0).max(1).optional(),
 })

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

@@ -6,7 +6,6 @@ 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<{
@@ -45,9 +44,6 @@ export declare const dataFormatSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 export type DataFormat = z.infer<typeof dataFormatSchema>;
 export declare const dataSchemaOf: (format: DataFormat) => JsonSchema;
 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;
@@ -67,7 +63,8 @@ export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA;
 export type PropagationOptions<N> = {
     viewPortSchemasOf?: (node: N) => {
         in: DeclaredPortSchema;
-        out: DeclaredPortSchema;
+        approve: DeclaredPortSchema;
+        reject: JsonSchema;
     } | null | undefined;
 };
 export declare const resolvePortSchemas: <N extends PropagationNode>(nodes: N[], connections: PortLink[], options?: PropagationOptions<N>) => Map<string, JsonSchema>;