@mawaru/sdk 0.13.0 → 0.15.0

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）
@@ -179,30 +147,28 @@ const FIXED_PORT_KEYS: Record<string, { in: string[]; out: string[] }> = {
   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"])
+// component は in（子 loop の start.in 契約）1つ＋ out は子 end の in ポートの射影
+// （複数可。end の in が1つなら互換のため main 1口）。スキーマ・構成とも保存時に
+// サーバが子 loop の契約から焼き込む宣言型（DERIVED/MIRROR には入れない＝接続で潰さない。
+// コンポーネントの複数入口・複数出口.md）
+const FREE_OUT_KINDS = new Set(["program", "ai", "component"])
 
-// 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],
+  component: ["in"],
 }
 
 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 +231,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 +276,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 +302,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 +322,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 +387,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 +420,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/duplicate-selection.js

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

package/dist/_schemas/extract-component.d.ts

@@ -4,8 +4,8 @@ export type ExtractAnalysis = {
     reason: string;
 } | {
     ok: true;
-    entryNodeId: string | null;
-    exitPortId: string | null;
+    entryPortIds: string[];
+    exitPortIds: string[];
     internal: GraphConnection[];
     inbound: GraphConnection[];
     outbound: GraphConnection[];
@@ -14,6 +14,7 @@ export declare const analyzeExtractSelection: (nodes: GraphNode[], connections:
 export type ExtractPlan = {
     childNodes: GraphNode[];
     childConnections: GraphConnection[];
+    childEnd: GraphNode;
     groupNode: GraphNode;
     parentNodes: GraphNode[];
     parentConnections: GraphConnection[];
@@ -25,7 +26,7 @@ export declare const buildExtractPlan: (params: {
     name: string;
     componentLoopId: string;
     childStartOutPortId: string;
-    childEndInPortId: string;
+    childEnd: GraphNode;
     newId: () => string;
 }) => {
     ok: false;