@mawaru/sdk 0.9.0 → 0.13.0

package/_schemas/port-spec.ts

@@ -302,6 +302,24 @@ type PropagationNode = {
 }
 type PortLink = { from_port_id: string; to_port_id: string }
 
+// 「上流の out をそのままコピーする」（in）／「in と同型」（approve）を表す指示。
+// 承認ビューのカタログ（@mawaru/common）の COPY_UPSTREAM と同じ値
+export const COPY_UPSTREAM_SCHEMA = "T"
+
+// ポートの型宣言：具体型か、上流からのコピー指示か
+export type DeclaredPortSchema = JsonSchema | typeof COPY_UPSTREAM_SCHEMA
+
+// 伝播のオプション。sdk は承認ビューのカタログを知らない（非公開。企業向けビューの
+// キーが npm 公開物に載るのを避ける）ので、呼び出し元が解決して渡す
+// → docs/tasks/wip/Humanの入出力を承認ビューの宣言に一本化する.md
+export type PropagationOptions<N> = {
+  // human の in / approve に転写する型（承認ビューの宣言）。null / undefined なら
+  // その node は対象外（human 以外）。上流ノードの kind は一切見ない
+  viewPortSchemasOf?: (
+    node: N,
+  ) => { in: DeclaredPortSchema; out: DeclaredPortSchema } | null | undefined
+}
+
 // end も導出ノード（各 in は上流から、out main は未宣言）。個別処理は
 // resolvePortSchemas 内で行うが、初期スキーマを未宣言にするためここに含める。
 // start も導出ノード：out main は接続先の in から逆向きに転写し、in は out と同型
@@ -342,6 +360,7 @@ const constSchemaOf = (
 export const resolvePortSchemas = <N extends PropagationNode>(
   nodes: N[],
   connections: PortLink[],
+  options?: PropagationOptions<N>,
 ): Map<string, JsonSchema> => {
   const resolved = new Map<string, JsonSchema>()
   const kindByPortId = new Map<string, string>()
@@ -427,20 +446,24 @@ export const resolvePortSchemas = <N extends PropagationNode>(
         if (!isUndeclaredSchema(inSchema)) assign(inPort.id, inSchema)
         continue
       }
-      assign(inPort.id, inSchema)
-      // human の approve：接続元が AI ノードなら封筒 { data, description } を剥がして
-      // data 型を流す（承認は data だけを下流へ渡す）。それ以外の上流は従来どおり素通し
-      const fromAiNode =
-        sources.length === 1 &&
-        sources[0] !== undefined &&
-        kindByPortId.get(sources[0]) === "ai"
+      // 承認ビューの宣言を human のポートへそのまま転写する（上流ノードの kind は見ない）。
+      // "T" は「上流の out をコピー」（in）／「in と同型」（approve）。
+      // 上流の out は書き換えない：逆伝播すると fan-out 先のビューが食い違ったとき
+      // 型割れが config.json へ write-through され、元の出力宣言を黙って壊す。
+      // ズレは接続の型エラーで見せてユーザーの [修正する] で直す
+      const declared = options?.viewPortSchemasOf?.(node)
+      const effectiveIn =
+        declared && declared.in !== COPY_UPSTREAM_SCHEMA
+          ? declared.in
+          : inSchema
+      assign(inPort.id, effectiveIn)
       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) ?? UNDECLARED_SCHEMA)
-              : inSchema,
+            declared && declared.out !== COPY_UPSTREAM_SCHEMA
+              ? declared.out
+              : effectiveIn,
           )
         }
       }
@@ -455,8 +478,9 @@ export const resolvePortSchemas = <N extends PropagationNode>(
 export const propagateDerivedPorts = <N extends PropagationNode>(
   nodes: N[],
   connections: PortLink[],
+  options?: PropagationOptions<N>,
 ): N[] => {
-  const resolved = resolvePortSchemas(nodes, connections)
+  const resolved = resolvePortSchemas(nodes, connections, options)
   return nodes.map((node) => {
     let touched = false
     const ports = node.ports.map((port) => {

package/dist/_cli/credentials.d.ts

@@ -0,0 +1,14 @@
+export type Credentials = {
+    refresh_token: string;
+    access_token: string;
+    supabase_url: string;
+    supabase_key: string;
+    api_url: string;
+    email: string;
+};
+export declare const credentialsPath: () => string;
+export declare const loadCredentials: () => Credentials | null;
+export declare const saveCredentials: (credentials: Credentials) => string;
+export declare const clearCredentials: () => boolean;
+export declare const accessTokenFrom: (credentials: Credentials) => Promise<string>;
+export declare const requireCredentials: () => Credentials;

package/dist/_cli/credentials.js

@@ -0,0 +1,81 @@
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const credentialsPath = () => join(process.env.MAWARU_CONFIG_DIR ?? join(homedir(), ".mawaru"), "credentials.json");
+export const loadCredentials = () => {
+    try {
+        return JSON.parse(readFileSync(credentialsPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+};
+// 0600 で保存する（refresh token は実質アカウントそのもの）
+export const saveCredentials = (credentials) => {
+    const path = credentialsPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${JSON.stringify(credentials, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    chmodSync(path, 0o600);
+    return path;
+};
+export const clearCredentials = () => {
+    try {
+        rmSync(credentialsPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+// JWT の exp を見て、期限が近ければ refresh する。
+// 検証はしない（署名を確かめるのはサーバの仕事）。ここでは「無駄な 401 を避ける」だけ
+const expiresSoon = (accessToken) => {
+    try {
+        const payload = accessToken.split(".")[1];
+        if (!payload)
+            return true;
+        const { exp } = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+        if (typeof exp !== "number")
+            return true;
+        return exp * 1000 - Date.now() < 60_000;
+    }
+    catch {
+        return true;
+    }
+};
+// API を叩くための access token。必要なら refresh して credentials を更新する
+export const accessTokenFrom = async (credentials) => {
+    if (!expiresSoon(credentials.access_token))
+        return credentials.access_token;
+    const res = await fetch(`${credentials.supabase_url}/auth/v1/token?grant_type=refresh_token`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            apikey: credentials.supabase_key,
+        },
+        body: JSON.stringify({ refresh_token: credentials.refresh_token }),
+    });
+    if (!res.ok) {
+        throw new Error(`セッションの更新に失敗しました（HTTP ${res.status}）。\`mawaru login\` でログインし直してください。`);
+    }
+    const body = (await res.json());
+    if (!body.access_token || !body.refresh_token) {
+        throw new Error("セッションの更新に失敗しました。`mawaru login` でログインし直してください。");
+    }
+    saveCredentials({
+        ...credentials,
+        access_token: body.access_token,
+        refresh_token: body.refresh_token,
+    });
+    return body.access_token;
+};
+// ログイン必須のコマンドの入口。未ログインは案内して終了させる
+export const requireCredentials = () => {
+    const credentials = loadCredentials();
+    if (!credentials) {
+        throw new Error("ログインしていません。`mawaru login` を実行してください。");
+    }
+    return credentials;
+};

package/dist/_cli/login.d.ts

@@ -0,0 +1,5 @@
+export type LoginResult = {
+    email: string;
+    path: string;
+};
+export declare const runLogin: (timeoutMs?: number) => Promise<LoginResult>;

package/dist/_cli/login.js

@@ -0,0 +1,82 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { saveCredentials } from "./credentials.js";
+// `gh auth login` と同じループバック方式（RFC 8252）。
+// CLI が 127.0.0.1 の一時ポートで待ち受け、ブラウザで mawaru の /cli-auth を開く。
+// 承認するとブラウザがループバック URL へ**遷移**してトークンを渡す
+//（https のページから http へ fetch は混在コンテンツで塞がれるが、遷移なら通る）。
+const APP_URL = process.env.MAWARU_APP_URL ?? "https://app.mawaru.ai";
+const page = (title, message) => `<!doctype html><meta charset="utf-8"><title>${title}</title>` +
+    `<body style="font-family:system-ui;display:grid;place-items:center;height:100vh;margin:0">` +
+    `<div style="text-align:center"><h1 style="font-size:1.25rem">${title}</h1>` +
+    `<p style="color:#666">${message}</p></div></body>`;
+// ブラウザを開く（開けなければ URL を出して手で開いてもらう。依存は足さない）
+const openBrowser = (url) => {
+    const [command, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    try {
+        spawn(command, args, { stdio: "ignore", detached: true }).unref();
+    }
+    catch {
+        // 何もしない（URL は既に印字済み）
+    }
+};
+export const runLogin = async (timeoutMs = 5 * 60 * 1000) => {
+    // 別のローカルプロセスが投げ込んだ応答を受け付けないための照合値
+    const state = randomUUID();
+    return await new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (url.pathname !== "/callback") {
+                res.writeHead(404).end();
+                return;
+            }
+            const params = url.searchParams;
+            const finish = (status, title, message) => {
+                res.writeHead(status, { "content-type": "text/html; charset=utf-8" });
+                res.end(page(title, message));
+                server.close();
+            };
+            if (params.get("state") !== state) {
+                finish(400, "承認に失敗しました", "リクエストが一致しませんでした。");
+                reject(new Error("承認の照合値（state）が一致しませんでした"));
+                return;
+            }
+            const credentials = {
+                refresh_token: params.get("refresh_token") ?? "",
+                access_token: params.get("access_token") ?? "",
+                supabase_url: params.get("supabase_url") ?? "",
+                supabase_key: params.get("supabase_key") ?? "",
+                api_url: params.get("api_url") ?? "",
+                email: params.get("email") ?? "",
+            };
+            if (!credentials.refresh_token || !credentials.api_url) {
+                finish(400, "承認に失敗しました", "トークンを受け取れませんでした。");
+                reject(new Error("承認の応答にトークンが含まれていませんでした"));
+                return;
+            }
+            const path = saveCredentials(credentials);
+            finish(200, "ログインしました", "このタブを閉じて、ターミナルに戻ってください。");
+            resolve({ email: credentials.email, path });
+        });
+        server.on("error", reject);
+        // ループバックのみに束ねる（他ホストから叩かれないように）
+        server.listen(0, "127.0.0.1", () => {
+            const { port } = server.address();
+            const authUrl = new URL("/cli-auth", APP_URL);
+            authUrl.searchParams.set("callback", `http://127.0.0.1:${port}/callback`);
+            authUrl.searchParams.set("state", state);
+            console.log(`ブラウザで承認してください: ${authUrl}`);
+            openBrowser(authUrl.toString());
+        });
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error("承認がタイムアウトしました。もう一度お試しください。"));
+        }, timeoutMs);
+        server.on("close", () => clearTimeout(timer));
+    });
+};

package/dist/_cli/resumeSession.d.ts

@@ -0,0 +1,21 @@
+import { type Credentials } from "./credentials.js";
+export type StepRef = {
+    tenantId: string;
+    runId: string;
+    stepId: string;
+};
+export declare const parseStepUrl: (raw: string) => StepRef;
+export declare const recordedCwds: (transcript: string) => {
+    all: string[];
+    last: string | null;
+};
+export declare const findProjectDir: (cwd: string) => string | null;
+export type TranscriptRef = {
+    url: string;
+    session_id: string;
+    redacted?: number;
+};
+export declare const fetchTranscriptRef: (credentials: Credentials, ref: StepRef) => Promise<TranscriptRef>;
+export declare const downloadTranscript: (url: string) => Promise<string>;
+export declare const placeTranscript: (cwd: string, sessionId: string, transcript: string) => string;
+export declare const spawnClaudeResume: (sessionId: string) => Promise<number>;

package/dist/_cli/resumeSession.js

@@ -0,0 +1,125 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { accessTokenFrom } from "./credentials.js";
+// UI がコピーさせる web の URL から tenant / run / step を取り出す。
+// 3つを1つの貼れる文字列で運ぶために URL の形にしている
+export const parseStepUrl = (raw) => {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error(`URL として読めません: ${raw}`);
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    const runIndex = segments.indexOf("runs");
+    const stepIndex = segments.indexOf("steps");
+    const runId = runIndex >= 0 ? segments[runIndex + 1] : undefined;
+    const stepId = stepIndex >= 0 ? segments[stepIndex + 1] : undefined;
+    const tenantId = url.searchParams.get("tenant");
+    if (!runId || !stepId) {
+        throw new Error("run / step を含む URL ではありません（例: https://app.mawaru.ai/runs/<runId>/steps/<stepId>?tenant=<tenantId>）");
+    }
+    if (!tenantId) {
+        throw new Error("URL に ?tenant=<tenantId> がありません。run 詳細のコピーボタンで取得した URL をそのまま渡してください。");
+    }
+    return { tenantId, runId, stepId };
+};
+// transcript に記録された作業ディレクトリ（重複は畳み、最後に居た場所も返す）。
+// **現在地がそこと違っていても resume 自体は通ってしまう**ので、人間に見せて確認を取る
+export const recordedCwds = (transcript) => {
+    const all = [];
+    let last = null;
+    for (const line of transcript.split("\n")) {
+        if (!line)
+            continue;
+        let cwd;
+        try {
+            cwd = JSON.parse(line).cwd;
+        }
+        catch {
+            continue;
+        }
+        if (typeof cwd !== "string" || cwd.length === 0)
+            continue;
+        if (!all.includes(cwd))
+            all.push(cwd);
+        last = cwd;
+    }
+    return { all, last };
+};
+const projectsRoot = () => join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects");
+// 置き先のディレクトリを **規則を再実装せず観測で決める**（agent-runner の
+// _helpers/session.ts と同じ方針）。~/.claude/projects/*/*.jsonl の cwd を読み、
+// いま居るディレクトリと一致するものを選ぶ
+export const findProjectDir = (cwd) => {
+    const root = projectsRoot();
+    if (!existsSync(root))
+        return null;
+    for (const dir of readdirSync(root)) {
+        const path = join(root, dir);
+        let files;
+        try {
+            files = readdirSync(path).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            let head;
+            try {
+                head = readFileSync(join(path, file), "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (recordedCwds(head).all.includes(cwd))
+                return path;
+        }
+    }
+    return null;
+};
+// 段階3 のエンドポイントから署名 URL と session_id を得る
+export const fetchTranscriptRef = async (credentials, ref) => {
+    const token = await accessTokenFrom(credentials);
+    const res = await fetch(`${credentials.api_url}/tenants/${ref.tenantId}/runs/${ref.runId}/steps/${ref.stepId}/transcript`, { headers: { Authorization: `Bearer ${token}` } });
+    if (res.status === 404) {
+        throw new Error("この step には退避されたセッションがありません（AI ノード以外か、退避前の実行です）。");
+    }
+    if (!res.ok) {
+        throw new Error(`transcript を取得できませんでした（HTTP ${res.status}）`);
+    }
+    return (await res.json());
+};
+export const downloadTranscript = async (url) => {
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`transcript のダウンロードに失敗しました（HTTP ${res.status}）`);
+    }
+    return await res.text();
+};
+// 置き先へ書き込む。ディレクトリが見つからないのは「この repo でまだ claude を
+// 起動していない」ケースなので、観測できるようにしてから再実行してもらう
+export const placeTranscript = (cwd, sessionId, transcript) => {
+    const dir = findProjectDir(cwd);
+    if (!dir) {
+        throw new Error("このディレクトリの Claude Code プロジェクトが見つかりません。" +
+            "ここで一度 `claude` を起動してから、もう一度実行してください。");
+    }
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, `${sessionId}.jsonl`);
+    writeFileSync(file, transcript);
+    return file;
+};
+// stdio を引き継いで claude を起動する（そのまま対話に入る）
+export const spawnClaudeResume = (sessionId) => new Promise((resolve) => {
+    const child = spawn("claude", ["--resume", sessionId], { stdio: "inherit" });
+    child.on("error", () => {
+        console.error("claude を起動できませんでした。Claude Code をインストールしてから `claude --resume " +
+            `${sessionId}\` を実行してください。`);
+        resolve(1);
+    });
+    child.on("close", (code) => resolve(code ?? 0));
+});

package/dist/_cli/sessionCommand.d.ts

@@ -0,0 +1,3 @@
+export declare const runSessionResume: (stepUrl: string | undefined, options: {
+    yes: boolean;
+}) => Promise<number>;

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

@@ -1,17 +1,19 @@
 import { z } from "zod";
-export declare const AI_MODELS: readonly ["claude-opus-4-8", "claude-sonnet-5", "claude-haiku-4-5"];
+export declare const AI_MODELS: readonly ["claude-opus-5", "claude-opus-4-8", "claude-sonnet-5", "claude-haiku-4-5"];
 export declare const aiModelSchema: z.ZodEnum<{
+    "claude-opus-5": "claude-opus-5";
     "claude-opus-4-8": "claude-opus-4-8";
     "claude-sonnet-5": "claude-sonnet-5";
     "claude-haiku-4-5": "claude-haiku-4-5";
 }>;
 export type AiModel = z.infer<typeof aiModelSchema>;
-export declare const DEFAULT_AI_MODEL = "claude-opus-4-8";
+export declare const DEFAULT_AI_MODEL = "claude-opus-5";
 export declare const aiManifestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     model: z.ZodDefault<z.ZodEnum<{
+        "claude-opus-5": "claude-opus-5";
         "claude-opus-4-8": "claude-opus-4-8";
         "claude-sonnet-5": "claude-sonnet-5";
         "claude-haiku-4-5": "claude-haiku-4-5";

package/dist/_schemas/ai-manifest.js

@@ -1,14 +1,17 @@
 import { z } from "zod";
 import { jsonSchemaSchema } from "./node.js";
 import { isAiEnvelopeSchema, manifestInKeysViolation } from "./port-spec.js";
-// AI ノードのモデル選択肢（既定は Opus：下書き品質が価値の中心。費用はユーザー持ち）
+// AI ノードのモデル選択肢（既定は Opus：下書き品質が価値の中心。費用はユーザー持ち）。
+// エイリアス（"opus" 等）は採らずバージョンを固定する：実行のたびに黙って別モデルへ
+// 乗り換わると品質も費用も再現しないため。新モデルが出たらこの配列を足して SDK を publish する
 export const AI_MODELS = [
+    "claude-opus-5",
     "claude-opus-4-8",
     "claude-sonnet-5",
     "claude-haiku-4-5",
 ];
 export const aiModelSchema = z.enum(AI_MODELS);
-export const DEFAULT_AI_MODEL = "claude-opus-4-8";
+export const DEFAULT_AI_MODEL = "claude-opus-5";
 // nodes/ai/<dir>/config.json（実行repoの構造見直し）。AI ノードの定義（prompt/model/skills/
 // 入出力スキーマ/env）は repo 側が正で、エディタが取り込んで ports を自動生成する
 // （実行時の正は ports テーブルのまま。プログラム規約 v2 と同じ関係）。

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/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>;
@@ -81,12 +80,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;
@@ -136,15 +135,14 @@ 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>;
@@ -163,12 +161,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;
@@ -218,15 +216,14 @@ 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>;