@mawaru/sdk 0.11.0 → 0.14.1

package/dist/_cli/sessionCommand.js

@@ -0,0 +1,55 @@
+import { createInterface } from "node:readline/promises";
+import { requireCredentials } from "./credentials.js";
+import { downloadTranscript, fetchTranscriptRef, parseStepUrl, placeTranscript, recordedCwds, spawnClaudeResume, } from "./resumeSession.js";
+const confirm = async (question) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${question} [y/N] `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+};
+// `mawaru session resume <step URL> [--yes]`
+//
+// 取得 → 作業ディレクトリの確認 → 配置 → `claude --resume`。
+// **どこに cd すべきかは mawaru には分からない**（AI ノードの実行 repo と、エージェントが
+// 実際に触った repo は別物で、後者は setup.sh が workspace/ 配下に clone した対象 repo）。
+// なので推定せず、記録された cwd をそのまま見せて人間に判断させる
+export const runSessionResume = async (stepUrl, options) => {
+    if (!stepUrl) {
+        console.error("使い方: mawaru session resume <step URL> [--yes]\n" +
+            "run 詳細の AI ノードにあるコピーボタンで URL を取得できます。");
+        return 1;
+    }
+    // URL の誤りは通信より先に落とす
+    const ref = parseStepUrl(stepUrl);
+    const credentials = requireCredentials();
+    const transcriptRef = await fetchTranscriptRef(credentials, ref);
+    const transcript = await downloadTranscript(transcriptRef.url);
+    console.log(`取得: セッション ${transcriptRef.session_id}`);
+    if (transcriptRef.redacted) {
+        console.log(`（退避時に secret を ${transcriptRef.redacted} 箇所マスクしています）`);
+    }
+    const { all, last } = recordedCwds(transcript);
+    const cwd = process.cwd();
+    if (all.length > 0) {
+        console.log("このセッションの作業ディレクトリ:");
+        for (const dir of all) {
+            console.log(`  ${dir}${dir === last ? "（最後に居た場所）" : ""}`);
+        }
+    }
+    console.log(`現在地:\n  ${cwd}`);
+    if (!all.includes(cwd)) {
+        console.log("※ 記録された作業ディレクトリとは違います。記録上の絶対パスはここでは解決しません" +
+            "（エージェントは読めないパスに当たれば自分で見つけ直します）。");
+    }
+    if (!options.yes && !(await confirm("続けますか？"))) {
+        console.log("中止しました。");
+        return 1;
+    }
+    const file = placeTranscript(cwd, transcriptRef.session_id, transcript);
+    console.log(`配置: ${file}\n再開します…`);
+    return await spawnClaudeResume(transcriptRef.session_id);
+};

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.d.ts

@@ -0,0 +1,12 @@
+import type { GraphConnection, GraphNode } from "./graph.js";
+export declare const duplicateSelection: (params: {
+    nodes: GraphNode[];
+    connections: GraphConnection[];
+    selectedIds: readonly string[];
+    dx: number;
+    dy: number;
+    newId: () => string;
+}) => {
+    nodes: GraphNode[];
+    connections: GraphConnection[];
+};

package/dist/_schemas/duplicate-selection.js

@@ -0,0 +1,34 @@
+// 選択ノードのコピー＆ペースト・複製（ノードのコピー&ペーストと複数選択.md）。
+// 純関数（id 採番は newId で注入）。エディタとテストの両方から使う。
+//
+// グラフは全量置換 PUT なので、複製は「id を全部採番し直して足す」だけで成立する。
+// ポート数の制約（in は kind ごとに固定・out は1以上）や (io,key) のノード内一意は
+// ノードを丸ごと写すので自動的に保たれる。
+export const duplicateSelection = (params) => {
+    const { nodes, connections, selectedIds, dx, dy, newId } = params;
+    const selected = new Set(selectedIds);
+    // start / end は回路の構造ノードなので複製しない（選択に混ざっていても落とす）。
+    // 並び順は元グラフのまま（選択の指定順に依存させない）
+    const portIdMap = new Map();
+    const copied = nodes
+        .filter((n) => selected.has(n.id) && n.kind !== "start" && n.kind !== "end")
+        .map((n) => ({
+        ...n,
+        id: newId(),
+        ports: n.ports.map((p) => {
+            const portId = newId();
+            portIdMap.set(p.id, portId);
+            return { ...p, id: portId };
+        }),
+        position_x: n.position_x + dx,
+        position_y: n.position_y + dy,
+    }));
+    // 両端が複製対象のポートである線（＝選択内で完結する線）だけを張り替えて写す。
+    // 外部との線（入口・出口）はコピーしない
+    const copiedConnections = connections.flatMap((c) => {
+        const from = portIdMap.get(c.from_port_id);
+        const to = portIdMap.get(c.to_port_id);
+        return from && to ? [{ from_port_id: from, to_port_id: to }] : [];
+    });
+    return { nodes: copied, connections: copiedConnections };
+};

package/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

@@ -17,12 +17,12 @@ export declare const editableNodeKindSchema: z.ZodEnum<{
 }>;
 export type EditableNodeKind = z.infer<typeof editableNodeKindSchema>;
 export declare const graphNodeKindSchema: z.ZodEnum<{
+    start: "start";
+    end: "end";
     ai: "ai";
     human: "human";
     program: "program";
     wait: "wait";
-    start: "start";
-    end: "end";
     component: "component";
 }>;
 export type GraphNodeKind = z.infer<typeof graphNodeKindSchema>;
@@ -52,15 +52,14 @@ export declare const assignMemberSchema: z.ZodUnion<readonly [z.ZodUUID, z.ZodLi
 export type AssignMember = z.infer<typeof assignMemberSchema>;
 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";
             round_robin: "round_robin";
         }>>;
         approval_mode: z.ZodDefault<z.ZodEnum<{
-            any: "any";
             all: "all";
+            any: "any";
         }>>;
         units: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodUUID, z.ZodLiteral<"run_starter">]>>>>;
     }, z.core.$strip>;
@@ -68,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<{
@@ -81,12 +81,12 @@ export type GraphNodeHook = z.infer<typeof graphNodeHookSchema>;
 export declare const graphNodeSchema: z.ZodObject<{
     id: z.ZodUUID;
     kind: z.ZodEnum<{
+        start: "start";
+        end: "end";
         ai: "ai";
         human: "human";
         program: "program";
         wait: "wait";
-        start: "start";
-        end: "end";
         component: "component";
     }>;
     name: z.ZodString;
@@ -99,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";
@@ -136,21 +137,21 @@ export declare const graphNodeSchema: z.ZodObject<{
     }, 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";
                 round_robin: "round_robin";
             }>>;
             approval_mode: z.ZodDefault<z.ZodEnum<{
-                any: "any";
                 all: "all";
+                any: "any";
             }>>;
             units: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodUUID, z.ZodLiteral<"run_starter">]>>>>;
         }, z.core.$strip>;
     }, 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>;
@@ -163,12 +164,12 @@ export declare const saveGraphBodySchema: z.ZodObject<{
     nodes: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         kind: z.ZodEnum<{
+            start: "start";
+            end: "end";
             ai: "ai";
             human: "human";
             program: "program";
             wait: "wait";
-            start: "start";
-            end: "end";
             component: "component";
         }>;
         name: z.ZodString;
@@ -181,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";
@@ -218,21 +220,21 @@ export declare const saveGraphBodySchema: z.ZodObject<{
         }, 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";
                     round_robin: "round_robin";
                 }>>;
                 approval_mode: z.ZodDefault<z.ZodEnum<{
-                    any: "any";
                     all: "all";
+                    any: "any";
                 }>>;
                 units: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodUUID, z.ZodLiteral<"run_starter">]>>>>;
             }, z.core.$strip>;
         }, 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_]*$）。実行系ボディ
@@ -107,8 +107,6 @@ export const humanConfigSchema = z.object({
     // どのキーが実在するか・そのテナントが選べるかは保存時に mawaru 側が検証する
     // （カタログは非公開。@mawaru/common の approval-view.ts）。省略時は標準ビュー
     view: z.string().min(1).optional(),
-    // ビューに渡すパラメータ（列・ラベル・閾値など）。形はビューごとに違うので任意の JSON
-    view_config: z.unknown().nullish(),
     assignment: z
         .object({
         strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -158,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）から
@@ -258,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) {
@@ -307,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({
@@ -316,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 は許す（並行分岐）。
@@ -409,49 +398,21 @@ export const saveGraphBodySchema = z
                 message: "終了ノードからは接続できません",
             });
         }
-        // human の reject の接続先は AI の instruction ポートのみ。
-        // 差し戻しは「元のセッションに指示を与える」操作で、上流データの口（in）とは
-        // 意味が違う（docs/tasks/wip/ポートスキーマのany撲滅.md）
-        if (fromNode.kind === "human" &&
-            from.key === "reject" &&
-            !(toNode.kind === "ai" && to.key === AI_INSTRUCTION_PORT_KEY)) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["connections", i, "to_port_id"],
-                message: "差し戻し（reject）の接続先は AI ノードの instruction ポートのみです",
-            });
-        }
-        // instruction ポートに繋げるのは human の reject だけ（データを流し込ませない）
-        if (toNode.kind === "ai" &&
-            to.key === AI_INSTRUCTION_PORT_KEY &&
-            !(fromNode.kind === "human" && from.key === "reject")) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["connections", i, "to_port_id"],
-                message: "instruction ポートに接続できるのは human の差し戻し（reject）だけです",
-            });
-        }
+        // 差し戻し（reject）と instruction の組み合わせに kind の縛りも型固定も無い：
+        // reject の型はビューの宣言、instruction は ai の in の1つ（接続鏡映）でしかない
+        // → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
+        // 型検証は kind によらず常に 伝播型（out） ⊆ 伝播型（in）。
+        // 未宣言は unknown＝判断できないので通す（作りかけのグラフを保存できなくしない）。
+        // 接続鏡映する口（program / ai の in）とコピー宣言のビューは接続元の型を採用する
+        // ので自明に通り、実質の検証対象は宣言で固定された口
+        // （component の契約・宣言のあるビューの human.in）になる
         const fromSchema = resolved.get(conn.from_port_id) ?? from.schema;
-        // human の in はどの型でも接続できる（上流が AI なら封筒 { data, description }、
-        // それ以外は input 全体を data として表示する。型制約は課さない）
-        // program の in への接続は 伝播型 ⊆ 宣言スキーマ。in は接続鏡映（sticky）なので
-        // 具体型の接続では自明に通り、接続元が未宣言 × 宣言維持のときだけ従来の意味を持つ
-        // （未宣言は unknown＝判断できないので通す。作りかけのグラフを保存できなくしない）
         const toSchema = resolved.get(conn.to_port_id) ?? to.schema;
-        if (toNode.kind === "program" && !isSchemaSubset(fromSchema, toSchema)) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["connections", i, "to_port_id"],
-                message: "接続元の型が program の入力スキーマに適合しません（伝播型 ⊆ 宣言スキーマ）",
-            });
-        }
-        // component の in は子 loop の契約（焼き込み済み宣言）。program と同じ包含チェック
-        if (toNode.kind === "component" &&
-            !isSchemaSubset(fromSchema, toSchema)) {
+        if (!isSchemaSubset(fromSchema, toSchema)) {
             ctx.addIssue({
                 code: "custom",
                 path: ["connections", i, "to_port_id"],
-                message: "接続元の型がコンポーネントの入力契約に適合しません（伝播型 ⊆ 契約）",
+                message: `「${fromNode.name}」の出力が「${toNode.name}」の入力スキーマに適合しません`,
             });
         }
     });

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 export declare const hookEventSchema: z.ZodEnum<{
-    output: "output";
     input: "input";
+    output: "output";
     signal: "signal";
 }>;
 export type HookEvent = z.infer<typeof hookEventSchema>;
@@ -9,8 +9,8 @@ export declare const hookManifestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     on: z.ZodArray<z.ZodEnum<{
-        output: "output";
         input: "input";
+        output: "output";
         signal: "signal";
     }>>;
     env: z.ZodDefault<z.ZodArray<z.ZodString>>;

package/dist/_schemas/node.d.ts

@@ -1,12 +1,12 @@
 import { z } from "zod";
 export declare const nodeKindSchema: z.ZodEnum<{
+    start: "start";
+    end: "end";
     ai: "ai";
     human: "human";
     program: "program";
     guardrail: "guardrail";
     wait: "wait";
-    start: "start";
-    end: "end";
     component: "component";
 }>;
 export type NodeKind = z.infer<typeof nodeKindSchema>;
@@ -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;
@@ -62,8 +58,17 @@ type PortLink = {
     from_port_id: string;
     to_port_id: string;
 };
-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 declare const COPY_UPSTREAM_SCHEMA = "T";
+export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA;
+export type PropagationOptions<N> = {
+    viewPortSchemasOf?: (node: N) => {
+        in: DeclaredPortSchema;
+        approve: DeclaredPortSchema;
+        reject: JsonSchema;
+    } | null | undefined;
+};
+export declare const resolvePortSchemas: <N extends PropagationNode>(nodes: N[], connections: PortLink[], options?: PropagationOptions<N>) => Map<string, JsonSchema>;
+export declare const propagateDerivedPorts: <N extends PropagationNode>(nodes: N[], connections: PortLink[], options?: PropagationOptions<N>) => 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;