@ainecto/mcp 0.2.0 → 0.3.0

package/dist/bin/ainecto.js

@@ -10,18 +10,18 @@ var FileTokenStore = class {
   constructor(rootDir = join(homedir(), ".ainecto")) {
     this.filePath = join(rootDir, "tokens.json");
   }
-  async load(endpoint) {
+  async load(endpoint, role) {
     const file = await this.readFile();
-    return file[tokenKey(endpoint)];
+    return file[tokenKey(endpoint, role)];
   }
-  async save(endpoint, token) {
+  async save(endpoint, token, role) {
     const file = await this.readFile();
-    file[tokenKey(endpoint)] = { ...token, endpoint, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    file[tokenKey(endpoint, role)] = { ...token, endpoint, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
     await this.writeFile(file);
   }
-  async delete(endpoint) {
+  async delete(endpoint, role) {
     const file = await this.readFile();
-    delete file[tokenKey(endpoint)];
+    delete file[tokenKey(endpoint, role)];
     await this.writeFile(file);
   }
   async readFile() {
@@ -56,8 +56,9 @@ var FileTokenStore = class {
     await chmodIfPermissive(this.filePath, 384);
   }
 };
-function tokenKey(endpoint) {
-  return createHash("sha256").update(endpoint).digest("hex");
+function tokenKey(endpoint, role) {
+  const material = role && role.trim() ? `${endpoint}#role=${role.trim().toLowerCase()}` : endpoint;
+  return createHash("sha256").update(material).digest("hex");
 }
 function isNodeError(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
@@ -108,6 +109,9 @@ function normalizeEndpoint(endpoint) {
   url.hash = "";
   return url.toString().replace(/\/$/, "");
 }
+function isDefaultEndpointFor(env, endpoint) {
+  return normalizeEndpoint(endpoint) === DEFAULT_ENDPOINTS[env];
+}
 function isDefaultEndpoint(endpoint) {
   const normalized = normalizeEndpoint(endpoint);
   return Object.values(DEFAULT_ENDPOINTS).includes(normalized) || LEGACY_DEFAULT_ENDPOINTS.includes(normalized);
@@ -173,6 +177,31 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/core/harness/role.ts
+var HARNESS_ROLES = ["design", "development", "test", "validation"];
+var ROLE_SCOPE_PREFIX = "ai-erd:role:";
+var ROLE_HEADER = "X-AI-ERD-Role";
+var ROLE_ENV_VAR = "AI_ERD_ROLE";
+function resolveRole(input = {}) {
+  if (input.role !== void 0) {
+    return { role: assertRole(input.role), source: "flag" };
+  }
+  const fromEnv = (input.envVars ?? process.env)[ROLE_ENV_VAR];
+  if (fromEnv && fromEnv.trim()) {
+    return { role: assertRole(fromEnv), source: "env" };
+  }
+  return { source: "none" };
+}
+function assertRole(value) {
+  const normalized = value.trim().toLowerCase();
+  if (HARNESS_ROLES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid role "${value}". Expected one of: ${HARNESS_ROLES.join(", ")}.`
+  );
+}
+
 // src/core/auth/oauth.ts
 var OAuthClient = class {
   constructor(options) {
@@ -191,7 +220,7 @@ var OAuthClient = class {
       assertEnvTokenEndpointAllowed(this.options.endpoint, this.envVars);
       return envToken;
     }
-    const stored = await this.options.tokenStore.load(this.options.endpoint);
+    const stored = await this.options.tokenStore.load(this.options.endpoint, this.options.role);
     if (!stored) {
       return void 0;
     }
@@ -201,7 +230,7 @@ var OAuthClient = class {
     return this.refreshStoredToken(stored);
   }
   async refreshAfterUnauthorized() {
-    const stored = await this.options.tokenStore.load(this.options.endpoint);
+    const stored = await this.options.tokenStore.load(this.options.endpoint, this.options.role);
     if (!stored?.refreshToken) {
       return void 0;
     }
@@ -222,6 +251,9 @@ var OAuthClient = class {
       authorizeUrl.searchParams.set("code_challenge_method", "S256");
       authorizeUrl.searchParams.set("resource", this.options.endpoint);
       authorizeUrl.searchParams.set("state", state);
+      if (this.options.role) {
+        authorizeUrl.searchParams.set("scope", `mcp ${ROLE_SCOPE_PREFIX}${this.options.role}`);
+      }
       assertTrustedEndpointUrl(authorizeUrl, "OAuth authorization URL");
       await this.openBrowserImpl(authorizeUrl.toString());
       const code = await loopback.waitForCode();
@@ -235,14 +267,14 @@ var OAuthClient = class {
         ...registration.clientSecret ? { client_secret: registration.clientSecret } : {}
       }, this.fetchImpl);
       const stored = toStoredToken(this.options.endpoint, token, metadata, registration);
-      await this.options.tokenStore.save(this.options.endpoint, stored);
+      await this.options.tokenStore.save(this.options.endpoint, stored, this.options.role);
       return stored;
     } finally {
       await loopback.close();
     }
   }
   async logout() {
-    await this.options.tokenStore.delete(this.options.endpoint);
+    await this.options.tokenStore.delete(this.options.endpoint, this.options.role);
   }
   async refreshStoredToken(stored) {
     if (!stored.refreshToken) {
@@ -257,7 +289,7 @@ var OAuthClient = class {
       resource: this.options.endpoint
     }, this.fetchImpl);
     const next = toStoredToken(this.options.endpoint, token, metadata, stored);
-    await this.options.tokenStore.save(this.options.endpoint, next);
+    await this.options.tokenStore.save(this.options.endpoint, next, this.options.role);
     return next.accessToken;
   }
 };
@@ -364,8 +396,8 @@ function toStoredToken(endpoint, token, metadata, previous) {
 async function createLoopbackReceiver(expectedState) {
   let resolveCode;
   let rejectCode;
-  const codePromise = new Promise((resolve, reject) => {
-    resolveCode = resolve;
+  const codePromise = new Promise((resolve2, reject) => {
+    resolveCode = resolve2;
     rejectCode = reject;
   });
   codePromise.catch(() => void 0);
@@ -396,7 +428,7 @@ async function createLoopbackReceiver(expectedState) {
     res.end("Ainecto CLI authorization complete. You can close this tab.");
     resolveCode(code);
   });
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  await new Promise((resolve2) => server.listen(0, "127.0.0.1", resolve2));
   const address = server.address();
   if (!address || typeof address === "string") {
     throw new Error("Loopback OAuth server did not bind to a TCP port.");
@@ -404,7 +436,7 @@ async function createLoopbackReceiver(expectedState) {
   return {
     redirectUri: `http://127.0.0.1:${address.port}/callback`,
     waitForCode: () => codePromise,
-    close: () => new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()))
+    close: () => new Promise((resolve2, reject) => server.close((error) => error ? reject(error) : resolve2()))
   };
 }
 function parseStringArray(value) {
@@ -589,6 +621,9 @@ var McpRpcClient = class {
     if (token) {
       headers.authorization = `Bearer ${token}`;
     }
+    if (this.options.role) {
+      headers[ROLE_HEADER.toLowerCase()] = this.options.role;
+    }
     return this.fetchImpl(this.options.endpoint, {
       method: "POST",
       headers,
@@ -596,6 +631,9 @@ var McpRpcClient = class {
     });
   }
 };
+function isToolError(result) {
+  return isRecord2(result) && result.isError === true;
+}
 function isJsonRpcResponse(value) {
   return isRecord2(value) && value.jsonrpc === "2.0" && ("result" in value || "error" in value);
 }
@@ -884,8 +922,12 @@ function isRecord3(value) {
 // src/adapters/mcp/connector.ts
 async function runConnector(options) {
   const tokenStore = new FileTokenStore();
-  const auth = new OAuthClient({ endpoint: options.endpoint, tokenStore });
-  const client = new McpRpcClient({ endpoint: options.endpoint, tokenProvider: auth });
+  const auth = new OAuthClient({ endpoint: options.endpoint, tokenStore, role: options.role });
+  const client = new McpRpcClient({
+    endpoint: options.endpoint,
+    tokenProvider: auth,
+    role: options.role
+  });
   await runStdioBridge({
     input: options.input,
     output: options.output,
@@ -1284,7 +1326,7 @@ async function executeGeneratedCommand(options) {
     warnings,
     presentation: route.presentation
   }));
-  return 0;
+  return isToolError(result) ? 1 : 0;
 }
 function renderGeneratedResult(result, options) {
   if (!options.json && options.presentation?.outputHint === "table") {
@@ -1701,166 +1743,1965 @@ function renderAttachmentUploadResult(result, json) {
   return renderSuccess(lines.join("\n"), { json: false });
 }
 
-// src/adapters/cli/ainectoCli.ts
-async function runAinectoCli(argv, io) {
-  let parsed = { json: argv.includes("--json"), help: false, positionals: [] };
+// src/adapters/cli/initCommand.ts
+import { chmod as chmod2, lstat, mkdir as mkdir2, readFile as readFile4, realpath, rename as rename2, rm as rm2, rmdir, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2, relative, resolve, sep } from "path";
+
+// src/core/harness/agentTargets.ts
+var SERVER_NAME = "ai-erd";
+var PACKAGE_NAME = "@ai-erd/mcp";
+var AGENT_TARGETS = [
+  { id: "claude-code", label: "Claude Code", path: ".mcp.json" },
+  { id: "cursor", label: "Cursor", path: ".cursor/mcp.json" }
+];
+function buildServerEntry(input) {
+  const args = ["-y", PACKAGE_NAME, "--role", input.role];
+  if (input.env && input.env !== "prod") {
+    args.push("--env", input.env);
+  }
+  if (input.endpoint && !isDefaultEndpointFor(input.env ?? "prod", input.endpoint)) {
+    args.push("--endpoint", input.endpoint);
+  }
+  return { command: "npx", args };
+}
+function readRoleFromEntry(entry) {
+  if (!isRecord7(entry) || !Array.isArray(entry.args)) {
+    return void 0;
+  }
+  const index = entry.args.indexOf("--role");
+  const value = index >= 0 ? entry.args[index + 1] : void 0;
+  return typeof value === "string" && HARNESS_ROLES.includes(value) ? value : void 0;
+}
+function readServerEntry(existing) {
+  if (existing === void 0) {
+    return void 0;
+  }
   try {
-    parsed = parseGlobalArgs(argv);
-    if (parsed.help || parsed.positionals.length === 0) {
-      io.stdout.write(helpText());
-      return 0;
-    }
-    const resolved = resolveEndpoint({ env: parsed.env, endpoint: parsed.endpoint });
-    const tokenStore = new FileTokenStore();
-    const auth = new OAuthClient({ endpoint: resolved.endpoint, tokenStore });
-    const client = new McpRpcClient({ endpoint: resolved.endpoint, tokenProvider: auth });
-    const [domain, action, ...rest] = parsed.positionals;
-    if (domain === "mcp") {
-      await runConnector({
-        endpoint: resolved.endpoint,
-        input: io.stdin,
-        output: io.stdout,
-        errorOutput: io.stderr
-      });
-      return 0;
-    }
-    if (domain === "auth") {
-      return handleAuth(action, auth, resolved.endpoint, parsed.json, io);
-    }
-    if (isAttachmentsUploadCommand(domain, action)) {
-      return await executeAttachmentsUploadCommand({
-        argv: rest,
-        client,
-        json: parsed.json,
-        io
-      });
-    }
-    const generatedResult = await executeGeneratedCommand({
-      env: parsed.env ?? "prod",
-      argv: parsed.positionals,
-      client,
-      json: parsed.json,
-      io
-    });
-    if (generatedResult !== 2) {
-      return generatedResult;
-    }
-    if (domain === "tools") {
-      return handleTools(action, rest, parsed, client, io);
-    }
-    throw new Error(`Unknown command "${domain}".`);
+    const parsed = JSON.parse(existing);
+    return parsed?.mcpServers?.[SERVER_NAME];
+  } catch {
+    return void 0;
+  }
+}
+function mergeServerEntry(existing, entry) {
+  const root = parseConfigObject(existing);
+  const servers = readServers(root);
+  const replaced = Object.prototype.hasOwnProperty.call(servers, SERVER_NAME);
+  const replacedEntry = replaced ? servers[SERVER_NAME] : void 0;
+  servers[SERVER_NAME] = entry;
+  return { content: stringify({ ...root, mcpServers: servers }), replaced, replacedEntry };
+}
+function removeServerEntry(existing, restore) {
+  if (existing === void 0) {
+    return { removed: false, emptied: false };
+  }
+  const root = parseConfigObject(existing);
+  const servers = readServers(root);
+  const removed = Object.prototype.hasOwnProperty.call(servers, SERVER_NAME);
+  if (restore !== void 0) {
+    servers[SERVER_NAME] = restore.value;
+    return { content: stringify({ ...root, mcpServers: servers }), removed, emptied: false };
+  }
+  delete servers[SERVER_NAME];
+  const otherKeys = Object.keys(root).filter((key) => key !== "mcpServers");
+  const emptied = Object.keys(servers).length === 0 && otherKeys.length === 0;
+  return { content: stringify({ ...root, mcpServers: servers }), removed, emptied };
+}
+function codexAddCommand(input) {
+  const entry = buildServerEntry(input);
+  return `codex mcp add ${SERVER_NAME} -- ${entry.command} ${entry.args.join(" ")}`;
+}
+function codexProfileSetup(input) {
+  const entry = buildServerEntry(input);
+  return [
+    `Per-session roles in Codex use profiles. Put this in $CODEX_HOME/${input.role}.config.toml:`,
+    "",
+    `    [mcp_servers.${SERVER_NAME}]`,
+    `    command = "${entry.command}"`,
+    `    args = ${JSON.stringify(entry.args)}`,
+    "",
+    `Then start that session with: codex -p ${input.role}`,
+    "A profile entry with the same server name replaces the global one, so the session still sees exactly one."
+  ];
+}
+function codexRemoveCommand() {
+  return `codex mcp remove ${SERVER_NAME}`;
+}
+function readServers(root) {
+  const servers = root.mcpServers;
+  if (servers === void 0) {
+    return {};
+  }
+  if (!isRecord7(servers)) {
+    throw new Error(
+      'Existing MCP config has an "mcpServers" value that is not an object, so it was left untouched. Fix it by hand and run init again.'
+    );
+  }
+  return { ...servers };
+}
+function parseConfigObject(existing) {
+  if (existing === void 0 || !existing.trim()) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(existing);
   } catch (error) {
-    io.stderr.write(renderError(error, { json: parsed.json }));
-    return 1;
+    throw new Error(
+      `Existing MCP config is not valid JSON, so it was left untouched. Fix it by hand and run init again. (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+  if (!isRecord7(parsed)) {
+    throw new Error("Existing MCP config must be a JSON object; it was left untouched.");
   }
+  return parsed;
 }
-async function handleAuth(action, auth, endpoint, json, io) {
-  if (action === "login") {
-    await auth.login();
-    io.stdout.write(renderSuccess({ endpoint, authenticated: true }, { json }));
-    return 0;
+function stringify(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/harness/harnessDoc.ts
+var MARKER_BEGIN = "<!-- ai-erd:begin -->";
+var MARKER_END = "<!-- ai-erd:end -->";
+var HARNESS_DOC_PATH = ".ai-erd/HARNESS.md";
+var HARNESS_CONFIG_PATH = ".ai-erd/config.json";
+var HARNESS_RECORD_PATH = ".ai-erd/init-record.json";
+function renderHarnessDoc(input, template) {
+  return fillTemplate(template ?? DEFAULT_HARNESS_DOC, {
+    projectName: input.projectName,
+    projectUuid: input.projectUuid,
+    endpoint: input.endpoint
+  });
+}
+function fillTemplate(template, values) {
+  return template.replace(/\{\{([a-zA-Z0-9_]+)}}/g, (whole, name) => Object.prototype.hasOwnProperty.call(values, name) ? values[name] : whole);
+}
+var DOC_KEY = "HARNESS.DOC";
+var AGENT_NOTE_KEY = "HARNESS.AGENT_NOTE";
+var REQUIRED_VARIABLES = {
+  [DOC_KEY]: ["projectName", "projectUuid", "endpoint"],
+  [AGENT_NOTE_KEY]: ["harnessDocPath", "serverName"]
+};
+function documentContractProblem(key, body) {
+  for (const name of REQUIRED_VARIABLES[key] ?? []) {
+    if (!body.includes(`{{${name}}}`)) {
+      return `${key} is missing the required {{${name}}} placeholder`;
+    }
   }
-  if (action === "status") {
-    const token = await auth.getAccessToken();
-    io.stdout.write(renderSuccess({ endpoint, authenticated: Boolean(token) }, { json }));
-    return 0;
+  if (key === AGENT_NOTE_KEY) {
+    return managedBlockProblem(key, body);
   }
-  if (action === "logout") {
-    await auth.logout();
-    io.stdout.write(renderSuccess({ endpoint, authenticated: false }, { json }));
-    return 0;
+  return void 0;
+}
+var DEFAULT_HARNESS_DOC = `# AI-ERD Harness
+
+This repository is wired to an AI-ERD project. The design source of truth lives in AI-ERD,
+not in this repository's files.
+
+- Project: **{{projectName}}** (\`{{projectUuid}}\`)
+- MCP endpoint: {{endpoint}}
+
+## One session, one role
+
+A session picks exactly one role and keeps it for the whole session. The role comes from the
+MCP server configuration \u2014 not from this file, and not from anything an agent can change at
+runtime. The server exposes only the tools that role is allowed to use, so a tool that is out
+of role is not merely discouraged: it is absent.
+
+| Role | Owns | Must not |
+| --- | --- | --- |
+| Design | Requirements, ERD, domain and module boundaries, dependency direction, tasks | Write product or test code |
+| Development | Product code, following the approved design | Change requirements, ERD, architecture, or data ownership |
+| Test | Test scenarios and test code, running them and reading results | Change product code to make a test pass; change the design |
+| Validation | Judging the result against the design and the rules | Change anything; it reports PASS or FAIL with evidence |
+
+Every role can **read** the whole source of truth. Reading the design is how the other roles
+do their job. A session that cannot do something reports it in the session, to you.
+
+## When you are blocked
+
+If the work needs something your role cannot do, **stop and say so**. Do not look for a way
+around it: not by editing files the tools would have written, not by asking for the role to be
+changed mid-session, not by deferring the decision into the implementation.
+
+    The work needs a design change.
+    This is a Development Session, so I cannot make it.
+    Settle it in a Design Session, then continue here.
+
+Validation reports \`PASS\`, or \`FAIL\` with the rule violated, where it happened, the evidence,
+and which session should pick it up next.
+
+## Not every change needs four sessions
+
+A small change that fits the design already recorded in AI-ERD starts at Development. The rule
+is not "always run four steps" \u2014 it is that when a step is needed, it does not happen inside
+another role's session.
+
+## Switching roles
+
+Change the role in the MCP server configuration and start a new session:
+
+${AGENT_TARGETS.map((target) => `    ${target.label.padEnd(12)} ${target.path}`).join("\n")}
+    Codex        global config \u2014 use a profile: codex -p <role>, or set ${ROLE_ENV_VAR}
+
+Or run \`ai-erd init --role <design|development|test|validation>\` to rewrite them.
+
+---
+Generated by \`ai-erd init\`. Remove everything it wrote with \`ai-erd init --undo\`.
+`;
+function renderAgentNote(template) {
+  return fillTemplate(template ?? DEFAULT_AGENT_NOTE, {
+    harnessDocPath: HARNESS_DOC_PATH,
+    serverName: SERVER_NAME
+  });
+}
+var DEFAULT_AGENT_NOTE = `${MARKER_BEGIN}
+## AI-ERD Harness
+
+This repository uses AI-ERD as its design source of truth, and each session has one role
+(Design / Development / Test / Validation). Read \`{{harnessDocPath}}\` before doing work that
+touches requirements, the ERD, or architecture.
+
+The role of this session comes from the \`{{serverName}}\` MCP server configuration, and from the
+access token when you signed in with a role; the server states it in its \`initialize\`
+instructions and exposes only that role's tools. If the work needs something outside the role,
+stop and report which session is required.
+${MARKER_END}`;
+function managedBlockProblem(key, body) {
+  const trimmed = body.trim();
+  if (!trimmed.startsWith(MARKER_BEGIN)) {
+    return `${key} must begin with ${MARKER_BEGIN} \u2014 text outside the block is never removed by --undo`;
+  }
+  if (!trimmed.endsWith(MARKER_END)) {
+    return `${key} must end with ${MARKER_END} \u2014 text outside the block is never removed by --undo`;
+  }
+  const inner = trimmed.slice(MARKER_BEGIN.length, trimmed.length - MARKER_END.length);
+  if (inner.includes(MARKER_BEGIN) || inner.includes(MARKER_END)) {
+    return `${key} must contain exactly one ${MARKER_BEGIN} and one ${MARKER_END}`;
+  }
+  if (!inner.startsWith("\n")) {
+    return `${key} must put ${MARKER_BEGIN} alone on its own line`;
+  }
+  if (!inner.endsWith("\n")) {
+    return `${key} must put ${MARKER_END} alone on its own line`;
+  }
+  if (hasUnclosedFence(inner)) {
+    return `${key} contains an unclosed code fence \u2014 the closing marker would fall inside it`;
+  }
+  return void 0;
+}
+function hasUnclosedFence(content) {
+  let open;
+  for (const line of content.split("\n")) {
+    const fence = fenceOf(line);
+    if (!fence) continue;
+    if (!open) open = { char: fence.char, length: fence.length };
+    else if (fence.char === open.char && fence.length >= open.length && fence.info === "") open = void 0;
+  }
+  return open !== void 0;
+}
+function canonicalManagedBlock(block) {
+  return block.trim();
+}
+function upsertMarkerBlock(existing, block) {
+  const current = existing ?? "";
+  assertNoDanglingMarker(current);
+  const normalized = canonicalManagedBlock(block);
+  const range = markerRange(current);
+  const composed = range ? `${current.slice(0, range.start)}${normalized}${current.slice(range.end)}` : `${current.trim() ? `${current.replace(/\s*$/, "")}
+
+` : ""}${normalized}
+`;
+  assertComposedBlockIsOurs(composed, current);
+  return composed;
+}
+function assertComposedBlockIsOurs(composed, existing) {
+  if (ownedMarkerCount(composed, MARKER_BEGIN) === 1 && ownedMarkerCount(composed, MARKER_END) === 1) {
+    return;
   }
-  throw new Error("Expected auth login, auth status, or auth logout.");
+  const reason = hasUnclosedFence(existing) ? "this file ends inside an unclosed code fence, so the block would sit inside it" : "the block could not be found again once merged into this file";
+  throw new Error(
+    `ai-erd could not place its block where --undo would find it again \u2014 ${reason}. The file was left untouched; fix that and run again.`
+  );
 }
-async function handleTools(action, rest, parsed, client, io) {
-  if (action === "list") {
-    const tools = await client.toolsList();
-    io.stdout.write(renderSuccess(tools, { json: parsed.json }));
-    return 0;
+function assertNoDanglingMarker(content) {
+  const begins = ownedMarkerCount(content, MARKER_BEGIN);
+  const ends = ownedMarkerCount(content, MARKER_END);
+  if (begins !== ends || begins > 1) {
+    throw new Error(
+      `ai-erd markers are unbalanced (${begins} begin, ${ends} end). The file was left untouched \u2014 remove the stray ${MARKER_BEGIN} / ${MARKER_END} by hand and run again.`
+    );
   }
-  if (action === "call") {
-    const toolName = rest[0];
-    if (!toolName) {
-      throw new Error("Expected MCP tool name after tools call.");
+  if (begins === 0) {
+    return;
+  }
+  if (ownedMarkerIndex(content, MARKER_END, 0) < ownedMarkerIndex(content, MARKER_BEGIN, 0)) {
+    throw new Error(
+      `ai-erd markers are out of order (${MARKER_END} appears before ${MARKER_BEGIN}). The file was left untouched \u2014 fix the markers by hand and run again.`
+    );
+  }
+}
+function ownedMarkerCount(content, marker) {
+  let count = 0;
+  for (let at = ownedMarkerIndex(content, marker, 0); at >= 0; at = ownedMarkerIndex(content, marker, at + 1)) {
+    count += 1;
+  }
+  return count;
+}
+function isInsideFencedBlock(content, index) {
+  let open;
+  let offset = 0;
+  for (const line of content.split("\n")) {
+    const nextOffset = offset + line.length + 1;
+    if (index < nextOffset) {
+      return open !== void 0;
+    }
+    const fence = fenceOf(line);
+    if (fence) {
+      if (!open) {
+        open = { char: fence.char, length: fence.length };
+      } else if (fence.char === open.char && fence.length >= open.length && fence.info === "") {
+        open = void 0;
+      }
     }
-    const toolArgs = rest.slice(1);
-    const payloadOptions = parsePayloadArgs(toolArgs);
-    const payload = await parsePayloadSource({
-      file: payloadOptions.file,
-      inline: payloadOptions.inline,
-      stdin: io.stdin
-    });
-    const result = await client.toolsCall(toolName, payload.value);
-    io.stdout.write(renderSuccess(result, { json: parsed.json, warnings: payload.warnings }));
-    return 0;
+    offset = nextOffset;
   }
-  if (action === "catalog") {
-    const catalogEnv = parsed.env ?? "prod";
-    io.stdout.write(renderSuccess(getGeneratedTools(parsed.env ?? "prod"), {
-      json: parsed.json,
-      warnings: [catalogEnv === "dev" ? "Local dev catalog is a checked-in live sync snapshot; rerun sync:tools --env dev to refresh it." : "Local prod catalog is seed fixture only until authenticated prod live sync updates generated catalogs."]
-    }));
-    return 0;
+  return open !== void 0;
+}
+function fenceOf(line) {
+  const match = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+  if (!match) {
+    return void 0;
   }
-  throw new Error("Expected tools list, tools call <mcpName>, or tools catalog.");
+  const run = match[1];
+  const info = match[2].trim();
+  if (run.startsWith("`") && info.includes("`")) {
+    return void 0;
+  }
+  return { char: run[0], length: run.length, info };
 }
-function parseGlobalArgs(argv) {
-  const result = { json: false, help: false, positionals: [] };
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg) {
+function removeMarkerBlock(existing) {
+  const current = existing ?? "";
+  assertNoDanglingMarker(current);
+  const range = markerRange(current);
+  if (!range) {
+    return { content: current, removed: false, emptied: !current.trim() };
+  }
+  const before = current.slice(0, range.start).replace(/\n*$/, "");
+  const after = current.slice(range.end).replace(/^\n*/, "");
+  const stripped = before && after ? `${before}
+
+${after}` : before ? `${before}
+` : after;
+  return { content: stripped.trim() ? stripped : "", removed: true, emptied: !stripped.trim() };
+}
+function replaceMarkerBlockWith(content, block) {
+  const range = markerRange(content);
+  return range ? `${content.slice(0, range.start)}${block}${content.slice(range.end)}` : content;
+}
+var UNPAIRED_BEGIN = "(unpaired ai-erd begin)";
+var UNPAIRED_END = "(unpaired ai-erd end)";
+function markerEvidence(content) {
+  if (!content) {
+    return [];
+  }
+  const owned = markerRange(content);
+  const rest = owned === void 0 ? content : content.slice(0, owned.start) + content.slice(owned.end);
+  const evidence = [];
+  let cursor = 0;
+  let begins = 0;
+  let ends = 0;
+  while (true) {
+    const begin = rest.indexOf(MARKER_BEGIN, cursor);
+    const close = rest.indexOf(MARKER_END, cursor);
+    if (begin < 0 && close < 0) {
+      break;
+    }
+    if (begin < 0 || close >= 0 && close < begin) {
+      ends += 1;
+      cursor = close + MARKER_END.length;
       continue;
     }
-    if (arg === "--env") {
-      result.env = assertEnv(requireValue3(arg, argv[++index]));
-    } else if (arg === "--endpoint") {
-      result.endpoint = requireValue3(arg, argv[++index]);
-    } else if (arg === "--json") {
-      result.json = true;
-    } else if (arg === "--help" || arg === "-h") {
-      result.help = true;
-    } else {
-      result.positionals.push(arg);
+    const pairEnd = rest.indexOf(MARKER_END, begin + MARKER_BEGIN.length);
+    if (pairEnd < 0) {
+      begins += 1;
+      cursor = begin + MARKER_BEGIN.length;
+      continue;
     }
+    evidence.push(blockShape(rest.slice(begin, pairEnd + MARKER_END.length)));
+    cursor = pairEnd + MARKER_END.length;
   }
-  return result;
+  for (let i = 0; i < begins; i += 1) evidence.push(UNPAIRED_BEGIN);
+  for (let i = 0; i < ends; i += 1) evidence.push(UNPAIRED_END);
+  return evidence;
 }
-function parsePayloadArgs(argv) {
-  const result = {};
-  const inline = [];
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg) {
+function blockShape(block) {
+  return block.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+}
+function existingMarkerBlock(content) {
+  if (!content) {
+    return void 0;
+  }
+  const range = markerRange(content);
+  return range ? content.slice(range.start, range.end) : void 0;
+}
+function markerRange(content) {
+  const start = ownedMarkerIndex(content, MARKER_BEGIN, 0);
+  if (start < 0) {
+    return void 0;
+  }
+  const endMarker = ownedMarkerIndex(content, MARKER_END, start);
+  if (endMarker < 0) {
+    return void 0;
+  }
+  return { start, end: endMarker + MARKER_END.length };
+}
+function ownedMarkerIndex(content, marker, from) {
+  for (let at = content.indexOf(marker, from); at >= 0; at = content.indexOf(marker, at + 1)) {
+    const lineStart = content.lastIndexOf("\n", at - 1) + 1;
+    if (lineStart !== at) {
       continue;
     }
-    if (arg === "--file" || arg === "-f") {
-      result.file = requireValue3(arg, argv[++index]);
-    } else {
-      inline.push(arg);
+    const lineEnd = content.indexOf("\n", at);
+    const rest = (lineEnd < 0 ? content.slice(at) : content.slice(at, lineEnd)).slice(marker.length);
+    if (rest.trim() !== "") {
+      continue;
     }
+    if (isInsideFencedBlock(content, at)) {
+      continue;
+    }
+    return at;
   }
-  if (inline.length > 0) {
-    result.inline = inline.join(" ");
+  return -1;
+}
+
+// src/core/harness/initRecord.ts
+var RECORD_KIND = "ai-erd/init-record";
+var RECORD_VERSION = 2;
+var ABSENT = { at: "absent" };
+function emptyRecord() {
+  return { version: RECORD_VERSION, files: {}, createdDirectories: [] };
+}
+function readRecord(content) {
+  if (content === void 0) {
+    return { state: "absent" };
   }
-  return result;
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { state: "corrupt", reason: `${HARNESS_RECORD_PATH} is not valid JSON` };
+  }
+  if (!isObject(parsed)) {
+    return { state: "corrupt", reason: `${HARNESS_RECORD_PATH} is not a JSON object` };
+  }
+  if (parsed.kind !== RECORD_KIND) {
+    return {
+      state: "corrupt",
+      reason: `${HARNESS_RECORD_PATH} exists but is not an ai-erd record (kind=${JSON.stringify(parsed.kind)})`
+    };
+  }
+  if (parsed.version !== RECORD_VERSION) {
+    return {
+      state: "legacy",
+      reason: `${HARNESS_RECORD_PATH} was written by another version of this CLI (record version ${JSON.stringify(parsed.version)}, this CLI reads ${RECORD_VERSION})`
+    };
+  }
+  const files = parsed.files;
+  if (!isObject(files)) {
+    return { state: "corrupt", reason: `${HARNESS_RECORD_PATH} has no "files" object` };
+  }
+  const out = {};
+  for (const [path, raw] of Object.entries(files)) {
+    const read = readContract(raw);
+    if ("problem" in read) {
+      return {
+        state: "corrupt",
+        reason: `${HARNESS_RECORD_PATH} has an unusable entry for ${path} \u2014 it ${read.problem}`
+      };
+    }
+    out[path] = read.contract;
+  }
+  const directories = parsed.createdDirectories;
+  if (directories !== void 0 && !isStringArray(directories)) {
+    return { state: "corrupt", reason: `${HARNESS_RECORD_PATH} has a malformed createdDirectories` };
+  }
+  return {
+    state: "valid",
+    record: {
+      version: RECORD_VERSION,
+      files: out,
+      createdDirectories: directories === void 0 ? [] : [...directories]
+    }
+  };
 }
-function requireValue3(flag, value) {
-  if (!value || value.startsWith("--")) {
-    throw new Error(`${flag} requires a value.`);
+var LEGACY_MANAGED_KEYS = [
+  "created",
+  "originals",
+  "lastWritten",
+  "lastWrittenFragment",
+  "lastWrittenBody",
+  "replacedEntries",
+  "replacedBlocks",
+  "blockAdded",
+  "foreignMarkers"
+];
+function legacyManagedRecord(configContent) {
+  if (configContent === void 0) {
+    return false;
   }
-  return value;
+  let parsed;
+  try {
+    parsed = JSON.parse(configContent);
+  } catch {
+    return false;
+  }
+  if (!isObject(parsed) || !isObject(parsed.managed)) {
+    return false;
+  }
+  const managed = parsed.managed;
+  const hasLegacyShape = LEGACY_MANAGED_KEYS.some(
+    (key) => Object.prototype.hasOwnProperty.call(managed, key)
+  );
+  if (!hasLegacyShape) {
+    return false;
+  }
+  if (typeof parsed.generatedBy === "string") {
+    return true;
+  }
+  const lastWritten = managed.lastWritten;
+  return isObject(lastWritten) && Object.prototype.hasOwnProperty.call(lastWritten, HARNESS_CONFIG_PATH);
 }
-function helpText() {
-  return [
-    "Ainecto CLI",
-    "",
-    "Usage:",
-    "  ainecto auth login|status|logout [--env prod|dev] [--endpoint URL] [--json]",
-    "  ainecto tools list [--env prod|dev] [--endpoint URL] [--json]",
-    "  ainecto tools call <mcpName> [-f payload.json|@-] [inline-json] [--json]",
-    "  ainecto attachments upload --document-uuid <uuid> <file...> [--json]",
-    "  ainecto <generated-command> [flags] [-f payload.json] [--yes] [--json]",
-    "  ainecto mcp [--env prod|dev] [--endpoint URL]",
+function legacyManagedNotice(configPath) {
+  return `${configPath} holds an init record written by an older version of this CLI (a "managed" field). This version keeps its record in ${HARNESS_RECORD_PATH} and cannot read that one, so your saved originals are still in there and nothing was changed. Undo with the version that wrote it (for example: npx @ai-erd/mcp@0.2 ai-erd init --undo), then run this version again.`;
+}
+function serializeRecord(record) {
+  return `${JSON.stringify({
+    kind: RECORD_KIND,
+    version: RECORD_VERSION,
+    files: record.files,
+    createdDirectories: record.createdDirectories
+  }, null, 2)}
+`;
+}
+function readContract(raw) {
+  if (!isObject(raw)) {
+    return { problem: "is not a JSON object" };
+  }
+  const scope = raw.scope;
+  if (scope !== "whole" && scope !== "entry" && scope !== "block" && scope !== "fields") {
+    return { problem: `has an unknown scope (${JSON.stringify(raw.scope)})` };
+  }
+  if (typeof raw.createdByUs !== "boolean") {
+    return { problem: "does not say whether ai-erd created the file" };
+  }
+  const original = readOwned(raw.original);
+  const written = readOwned(raw.written);
+  if (original === void 0) {
+    return { problem: "has no readable record of what was there before" };
+  }
+  if (written === void 0) {
+    return { problem: "has no readable record of what ai-erd wrote" };
+  }
+  if (raw.fileFingerprint !== void 0 && typeof raw.fileFingerprint !== "string") {
+    return { problem: "has a malformed fileFingerprint" };
+  }
+  if (raw.writtenFields !== void 0 && !isObject(raw.writtenFields)) {
+    return { problem: "has a malformed writtenFields" };
+  }
+  let originalFields;
+  if (raw.originalFields !== void 0) {
+    if (!isObject(raw.originalFields)) {
+      return { problem: "has a malformed originalFields" };
+    }
+    originalFields = {};
+    for (const [field, value] of Object.entries(raw.originalFields)) {
+      const owned = readOwned(value);
+      if (owned === void 0) {
+        return { problem: `has no readable original for the field ${field}` };
+      }
+      originalFields[field] = owned;
+    }
+  }
+  if (raw.foreignBlocks !== void 0 && !isStringArray(raw.foreignBlocks)) {
+    return { problem: "has a malformed foreignBlocks" };
+  }
+  if (scope === "block" && raw.foreignBlocks === void 0) {
+    return { problem: "owns a marker block but does not say what marker blocks were already in the file" };
+  }
+  if (scope === "fields") {
+    const problem = fieldsContractProblem({
+      written,
+      writtenFields: isObject(raw.writtenFields) ? raw.writtenFields : void 0,
+      originalFields
+    });
+    if (problem !== void 0) {
+      return { problem };
+    }
+  }
+  const contract = {
+    scope,
+    createdByUs: raw.createdByUs,
+    original,
+    written
+  };
+  if (typeof raw.fileFingerprint === "string") contract.fileFingerprint = raw.fileFingerprint;
+  if (isObject(raw.writtenFields)) contract.writtenFields = { ...raw.writtenFields };
+  if (originalFields !== void 0) contract.originalFields = originalFields;
+  if (isStringArray(raw.foreignBlocks)) contract.foreignBlocks = [...raw.foreignBlocks];
+  return { contract };
+}
+function fieldsContractProblem(contract, ownedFields) {
+  const { written, writtenFields, originalFields } = contract;
+  if (writtenFields === void 0) {
+    return "owns only some fields of the file but does not say which ones it wrote (writtenFields)";
+  }
+  if (originalFields === void 0) {
+    return "owns only some fields of the file but does not say what was in them before (originalFields)";
+  }
+  const writtenKeys = Object.keys(writtenFields).sort();
+  const originalKeys = Object.keys(originalFields).sort();
+  if (writtenKeys.length !== originalKeys.length || writtenKeys.some((key, at) => key !== originalKeys[at])) {
+    return `lists different fields as written (${writtenKeys.join(", ") || "none"}) and as backed up (${originalKeys.join(", ") || "none"})`;
+  }
+  for (const key of writtenKeys) {
+    const original = originalFields[key];
+    if (original.at !== "absent" && original.at !== "json") {
+      return `records the original of ${key} as ${original.at}, which is not something --undo can put back into a JSON field`;
+    }
+  }
+  if (written.at !== "text") {
+    return "owns only some fields of the file but does not hold the file text it wrote";
+  }
+  let body;
+  try {
+    body = JSON.parse(written.text);
+  } catch {
+    return "holds a written file body that is not valid JSON";
+  }
+  if (!isObject(body)) {
+    return "holds a written file body that is not a JSON object";
+  }
+  for (const key of writtenKeys) {
+    if (!Object.prototype.hasOwnProperty.call(body, key)) {
+      return `says it wrote ${key}, but that field is not in the file body it recorded`;
+    }
+    if (stableStringify(body[key]) !== stableStringify(writtenFields[key])) {
+      return `records a different value for ${key} than the file body it wrote`;
+    }
+  }
+  if (ownedFields !== void 0) {
+    for (const key of ownedFields) {
+      if (Object.prototype.hasOwnProperty.call(body, key) && !Object.prototype.hasOwnProperty.call(writtenFields, key)) {
+        return `wrote ${key} into the file but does not record what it put there`;
+      }
+    }
+  }
+  return void 0;
+}
+function readOwned(raw) {
+  if (!isObject(raw)) {
+    return void 0;
+  }
+  if (raw.at === "absent") {
+    return ABSENT;
+  }
+  if (raw.at === "json") {
+    return Object.prototype.hasOwnProperty.call(raw, "value") ? { at: "json", value: raw.value } : void 0;
+  }
+  if (raw.at === "text") {
+    return typeof raw.text === "string" ? { at: "text", text: raw.text } : void 0;
+  }
+  return void 0;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+// src/core/harness/initPlan.ts
+import { createHash as createHash3 } from "crypto";
+var NOTE_TARGETS = [
+  { path: "AGENTS.md", createIfMissing: true },
+  { path: "CLAUDE.md", createIfMissing: false }
+];
+var MANAGED_PATHS = [
+  ...AGENT_TARGETS.map((target) => target.path),
+  ...NOTE_TARGETS.map((target) => target.path),
+  HARNESS_DOC_PATH,
+  HARNESS_CONFIG_PATH,
+  HARNESS_RECORD_PATH
+];
+function ownedJson(value, present) {
+  return present ? { at: "json", value } : ABSENT;
+}
+function ownedText(text) {
+  return text === void 0 ? ABSENT : { at: "text", text };
+}
+function sameOwned(left, right) {
+  if (left.at !== right.at) {
+    return false;
+  }
+  if (left.at === "absent") {
+    return true;
+  }
+  if (left.at === "text" && right.at === "text") {
+    return left.text === right.text;
+  }
+  return left.at === "json" && right.at === "json" && stableStringify(left.value) === stableStringify(right.value);
+}
+function contentFingerprint(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+function serialize(body) {
+  return `${JSON.stringify(body, null, 2)}
+`;
+}
+function fingerprintFor(path, content) {
+  if (!path.endsWith(".json")) {
+    return contentFingerprint(content);
+  }
+  try {
+    return contentFingerprint(stableStringify(JSON.parse(content)));
+  } catch {
+    return contentFingerprint(content);
+  }
+}
+function parseJsonObject(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function configBodyOf(values) {
+  return {
+    version: 1,
+    project: { uuid: values.projectUuid, name: values.projectName },
+    endpoint: values.endpoint,
+    generatedBy: values.cliVersion,
+    promptVersions: values.versions
+  };
+}
+var OUR_CONFIG_FIELDS = Object.keys(configBodyOf({
+  projectUuid: "",
+  projectName: "",
+  endpoint: "",
+  cliVersion: "",
+  versions: {}
+}));
+var hasField = (object, field) => Object.prototype.hasOwnProperty.call(object, field);
+function initRefusal(files, previous) {
+  const state = previous ?? readRecord(files.get(HARNESS_RECORD_PATH));
+  if (state.state === "corrupt" || state.state === "legacy") {
+    return `${state.reason}. Nothing was changed \u2014 move that file aside (or restore it) and run again.`;
+  }
+  if (state.state === "absent" && legacyManagedRecord(files.get(HARNESS_CONFIG_PATH))) {
+    return legacyManagedNotice(HARNESS_CONFIG_PATH);
+  }
+  const carried = state.state === "valid" ? state.record : emptyRecord();
+  for (const [path, contract] of Object.entries(carried.files)) {
+    if (contract.scope !== "fields") {
+      continue;
+    }
+    const problem = fieldsContractProblem(contract, OUR_CONFIG_FIELDS);
+    if (problem !== void 0) {
+      return `${HARNESS_RECORD_PATH}'s record for ${path} ${problem}. Nothing was changed \u2014 restore that file (or move it aside) and run again.`;
+    }
+  }
+  return void 0;
+}
+function planInit(input) {
+  const previous = input.previous ?? readRecord(input.files.get(HARNESS_RECORD_PATH));
+  const refusal = initRefusal(input.files, previous);
+  if (refusal !== void 0) {
+    return {
+      writes: [],
+      deletes: [],
+      notes: [],
+      codexCommand: codexAddCommand({ role: input.role, env: input.env, endpoint: input.endpoint }),
+      refusal
+    };
+  }
+  const carriedRecord = previous.state === "valid" ? previous.record : emptyRecord();
+  const entry = buildServerEntry({ role: input.role, env: input.env, endpoint: input.endpoint });
+  const writes = [];
+  const notes = [];
+  const record = {
+    version: carriedRecord.version,
+    files: { ...carriedRecord.files },
+    createdDirectories: [...carriedRecord.createdDirectories]
+  };
+  const priorOf = (path, current) => {
+    const prior = record.files[path];
+    if (prior === void 0) {
+      return void 0;
+    }
+    if (sameOwned(prior.written, current) || sameOwned(prior.original, current)) {
+      return prior;
+    }
+    delete record.files[path];
+    notes.push(`${path}: it changed outside ai-erd, so the older backup was dropped and this is the new baseline.`);
+    return void 0;
+  };
+  for (const target of AGENT_TARGETS) {
+    const existing = input.files.get(target.path);
+    const currentEntry = existing === void 0 ? void 0 : readServerEntry(existing);
+    const prior = priorOf(target.path, ownedJson(currentEntry, currentEntry !== void 0));
+    const merged = mergeServerEntry(existing, entry);
+    if (existing === merged.content) {
+      continue;
+    }
+    const before = previousRole(existing);
+    if (merged.replaced && before && before !== input.role) {
+      notes.push(`${target.path}: role ${before} \u2192 ${input.role}`);
+    }
+    const original = prior?.original ?? ownedJson(merged.replacedEntry, merged.replaced);
+    if (prior === void 0 && original.at !== "absent") {
+      notes.push(`${target.path}: your existing "${SERVER_NAME}" entry was saved and will be restored by --undo`);
+    }
+    record.files[target.path] = {
+      scope: "entry",
+      createdByUs: prior?.createdByUs ?? existing === void 0,
+      original,
+      written: ownedJson(readServerEntry(merged.content), true),
+      fileFingerprint: fingerprintFor(target.path, merged.content)
+    };
+    writes.push({ path: target.path, content: merged.content, existed: existing !== void 0 });
+  }
+  const existingDoc = input.files.get(HARNESS_DOC_PATH);
+  const priorDoc = priorOf(HARNESS_DOC_PATH, ownedText(existingDoc));
+  const docContent = renderHarnessDoc({
+    projectName: input.projectName,
+    projectUuid: input.projectUuid,
+    endpoint: input.endpoint
+  }, input.documents?.doc);
+  const docOriginal = priorDoc?.original ?? ownedText(existingDoc);
+  if (priorDoc === void 0 && docOriginal.at !== "absent") {
+    notes.push(`${HARNESS_DOC_PATH} already existed; its original was saved and --undo will restore it.`);
+  }
+  record.files[HARNESS_DOC_PATH] = {
+    scope: "whole",
+    createdByUs: priorDoc?.createdByUs ?? existingDoc === void 0,
+    original: docOriginal,
+    written: ownedText(docContent),
+    fileFingerprint: fingerprintFor(HARNESS_DOC_PATH, docContent)
+  };
+  if (docContent !== existingDoc) {
+    writes.push({ path: HARNESS_DOC_PATH, content: docContent, existed: existingDoc !== void 0 });
+  }
+  const note = renderAgentNote(input.documents?.agentNote);
+  for (const target of NOTE_TARGETS) {
+    const existing = input.files.get(target.path);
+    if (existing === void 0 && !target.createIfMissing) {
+      notes.push(`${target.path} not found \u2014 skipped; AGENTS.md already reaches this agent.`);
+      continue;
+    }
+    const blockNow = existing === void 0 ? void 0 : existingMarkerBlock(existing);
+    const carried = record.files[target.path];
+    let content;
+    try {
+      content = upsertMarkerBlock(existing, note);
+    } catch (error) {
+      notes.push(`${target.path}: ${error instanceof Error ? error.message : String(error)}`);
+      continue;
+    }
+    if (carried?.scope === "block" && unexplainedMarkers(existing, carried) > 0) {
+      notes.push(
+        `${target.path}: this file has an ai-erd marker block that is not where ai-erd can find it again (inside a code fence, a quote, or edited). Left untouched and the earlier backup kept \u2014 move that block back to the top level, or remove it, then run again.`
+      );
+      continue;
+    }
+    const prior = blockNow === void 0 ? carried : priorOf(target.path, ownedText(blockNow));
+    if (content === existing) {
+      continue;
+    }
+    const original = prior?.original ?? ownedText(blockNow);
+    if (prior === void 0 && original.at !== "absent") {
+      notes.push(`${target.path}: an existing ai-erd block was saved and will be restored by --undo`);
+    }
+    record.files[target.path] = {
+      scope: "block",
+      createdByUs: prior?.createdByUs ?? existing === void 0,
+      original,
+      written: ownedText(existingMarkerBlock(content)),
+      fileFingerprint: fingerprintFor(target.path, content),
+      // init «전»에 이 파일에 있던 관리 블록들의 신원. 되돌리기가 「남은 마커를 설명할 수 있나」를
+      // 이것으로 묻는다. ★재init 은 이어받는다 — 다시 재면 우리가 쓴 블록이 «원래 있던 것»이 된다.
+      // ★{@code carried} 를 먼저 본다 — {@code priorOf} 가 새 기준을 세웠다는 것이 「남의 예제
+      //   목록을 다시 모아도 된다」는 허가가 아니다. 다시 모으면 «우리가 옮겨 둔 사본»이
+      //   「원래 있던 예제」로 등록되고, 그다음 되돌리기가 그것을 남긴 채 끝났다(3차 리뷰 B2).
+      foreignBlocks: carried?.foreignBlocks ?? prior?.foreignBlocks ?? markerEvidence(existing)
+    };
+    writes.push({ path: target.path, content, existed: existing !== void 0 });
+  }
+  const existingConfig = input.files.get(HARNESS_CONFIG_PATH);
+  const ourFields = configBodyOf({
+    projectUuid: input.projectUuid,
+    projectName: input.projectName,
+    endpoint: input.endpoint,
+    cliVersion: input.cliVersion,
+    // ★어느 판의 규칙으로 썼나. 이게 없으면 「무엇이 적혀 있었나」를 나중에 못 되짚는다.
+    versions: input.documents?.versions ?? {}
+  });
+  const theirConfig = existingConfig === void 0 ? void 0 : parseJsonObject(existingConfig);
+  if (existingConfig !== void 0 && theirConfig === void 0) {
+    notes.push(`${HARNESS_CONFIG_PATH} is not a JSON object \u2014 left untouched.`);
+  } else {
+    const priorConfig = record.files[HARNESS_CONFIG_PATH];
+    const originalFields = {};
+    for (const field of OUR_CONFIG_FIELDS) {
+      const presentNow = theirConfig !== void 0 && hasField(theirConfig, field);
+      const currentValue = presentNow ? theirConfig[field] : void 0;
+      const priorOriginal = priorConfig?.originalFields?.[field];
+      const priorWritten = priorConfig?.writtenFields;
+      const untouchedByUser = priorWritten !== void 0 && hasField(priorWritten, field) && stableStringify(currentValue) === stableStringify(priorWritten[field]);
+      const next = untouchedByUser && priorOriginal !== void 0 ? priorOriginal : ownedJson(currentValue, presentNow);
+      originalFields[field] = next;
+      if (priorOriginal !== void 0 && !sameOwned(next, priorOriginal)) {
+        notes.push(`${HARNESS_CONFIG_PATH}: you changed ${field} \u2014 ai-erd now treats your value as the one to put back.`);
+      }
+    }
+    const mergedConfig = serialize({ ...theirConfig ?? {}, ...ourFields });
+    record.files[HARNESS_CONFIG_PATH] = {
+      scope: "fields",
+      createdByUs: priorConfig?.createdByUs ?? existingConfig === void 0,
+      original: ABSENT,
+      written: ownedText(mergedConfig),
+      fileFingerprint: fingerprintFor(HARNESS_CONFIG_PATH, mergedConfig),
+      writtenFields: { ...ourFields },
+      originalFields
+    };
+    if (mergedConfig !== existingConfig) {
+      writes.push({
+        path: HARNESS_CONFIG_PATH,
+        content: mergedConfig,
+        existed: existingConfig !== void 0
+      });
+    }
+  }
+  const existingRecord = input.files.get(HARNESS_RECORD_PATH);
+  const recordContent = serializeRecord(record);
+  if (recordContent !== existingRecord) {
+    writes.push({
+      path: HARNESS_RECORD_PATH,
+      content: recordContent,
+      existed: existingRecord !== void 0
+    });
+  }
+  return {
+    writes,
+    deletes: [],
+    codexCommand: codexAddCommand({ role: input.role, env: input.env, endpoint: input.endpoint }),
+    codexProfile: codexProfileSetup({ role: input.role, env: input.env, endpoint: input.endpoint }),
+    notes,
+    record
+  };
+}
+function planUndo(input) {
+  const state = input.record ?? readRecord(input.files.get(HARNESS_RECORD_PATH));
+  const writes = [];
+  const deletes = [];
+  const notes = [];
+  const tail = () => {
+    notes.push(`Codex keeps its own global config \u2014 remove it with: ${codexRemoveCommand()}`);
+    notes.push(`If you set ${ROLE_ENV_VAR} anywhere, unset it too.`);
+  };
+  if (state.state === "absent") {
+    notes.push(legacyManagedRecord(input.files.get(HARNESS_CONFIG_PATH)) ? legacyManagedNotice(HARNESS_CONFIG_PATH) : `No record of a previous init in ${HARNESS_RECORD_PATH} \u2014 no local file was changed.`);
+    tail();
+    return { writes, deletes, codexCommand: codexRemoveCommand(), notes };
+  }
+  if (state.state !== "valid") {
+    notes.push(
+      `${state.reason}. Nothing was changed \u2014 that file is kept because it may hold backups --undo still needs. Restore it, or finish the undo with the CLI version that wrote it.`
+    );
+    tail();
+    return { writes, deletes, codexCommand: codexRemoveCommand(), notes };
+  }
+  const record = state.record;
+  const remaining = { ...record.files };
+  for (const [path, contract] of Object.entries(record.files)) {
+    const outcome = undoOne(path, contract, input.files.get(path));
+    if (outcome.kind !== "unresolved" && outcome.kind !== "keep" && outcome.note !== void 0) {
+      notes.push(outcome.note);
+    } else if (outcome.kind === "unresolved" || outcome.kind === "keep") {
+      notes.push(outcome.note);
+    }
+    if (outcome.kind === "unresolved") {
+      continue;
+    }
+    delete remaining[path];
+    if (outcome.kind === "write") {
+      writes.push({ path, content: outcome.content, existed: true });
+    } else if (outcome.kind === "delete") {
+      deletes.push(path);
+    }
+  }
+  tail();
+  if (input.files.get(HARNESS_RECORD_PATH) !== void 0) {
+    if (Object.keys(remaining).length > 0) {
+      const reduced = { ...record, files: remaining };
+      writes.push({ path: HARNESS_RECORD_PATH, content: serializeRecord(reduced), existed: true });
+      notes.push(
+        `${HARNESS_RECORD_PATH}: kept, with the finished items removed \u2014 it still holds the backups --undo needs. Run --undo again once the items above are resolved.`
+      );
+    } else {
+      deletes.push(HARNESS_RECORD_PATH);
+    }
+  }
+  const removableDirectories = parentsOf(deletes).filter((directory) => record.createdDirectories.includes(directory));
+  return { writes, deletes, codexCommand: codexRemoveCommand(), notes, removableDirectories };
+}
+function unexplainedMarkers(existing, contract) {
+  const recorded = [...contract.foreignBlocks ?? []];
+  let unexplained = 0;
+  for (const print of markerEvidence(existing)) {
+    const at = recorded.indexOf(print);
+    if (at >= 0) {
+      recorded.splice(at, 1);
+    } else {
+      unexplained += 1;
+    }
+  }
+  return unexplained;
+}
+function undoOne(path, contract, existing) {
+  if (existing === void 0) {
+    if (contract.original.at !== "absent" || contract.scope === "fields") {
+      return {
+        kind: "unresolved",
+        note: `${path} is gone, so what was there before init could not be put back \u2014 the backup is kept. Restore the file and run --undo again.`
+      };
+    }
+    return { kind: "done" };
+  }
+  switch (contract.scope) {
+    case "entry":
+      return undoEntry(path, contract, existing);
+    case "block":
+      return undoBlock(path, contract, existing);
+    case "fields":
+      return undoFields(path, contract, existing);
+    case "whole":
+      return undoWhole(path, contract, existing);
+  }
+}
+function undoEntry(path, contract, existing) {
+  const current = readServerEntry(existing);
+  const currentOwned = ownedJson(current, current !== void 0);
+  if (sameOwned(currentOwned, contract.original)) {
+    return {
+      kind: "done",
+      note: contract.original.at === "absent" ? `${path}: the "${SERVER_NAME}" entry ai-erd added is already gone.` : `${path}: your original "${SERVER_NAME}" entry is already back in place.`
+    };
+  }
+  const goneButWeHoldTheOriginal = current === void 0 && contract.original.at !== "absent";
+  if (!goneButWeHoldTheOriginal && !sameOwned(currentOwned, contract.written)) {
+    return {
+      kind: "unresolved",
+      note: `${path}: the "${SERVER_NAME}" entry was edited after init \u2014 left in place. Remove it by hand if you meant to, then run --undo again.`
+    };
+  }
+  const restore = contract.original.at === "json" ? { value: contract.original.value } : void 0;
+  const result = removeServerEntry(existing, restore);
+  if (result.emptied && contract.createdByUs) {
+    return { kind: "delete" };
+  }
+  if (result.content !== void 0 && result.content !== existing) {
+    return {
+      kind: "write",
+      content: result.content,
+      note: restore === void 0 ? void 0 : `${path}: restored your original "${SERVER_NAME}" entry.`
+    };
+  }
+  return { kind: "done" };
+}
+function undoBlock(path, contract, existing) {
+  const current = existingMarkerBlock(existing);
+  const currentOwned = ownedText(current);
+  if (unexplainedMarkers(existing, contract) > 0) {
+    return {
+      kind: "unresolved",
+      note: `${path}: this file has an ai-erd marker block that --undo cannot account for (inside a code fence, a quote, or edited). Remove it by hand, then run --undo again.`
+    };
+  }
+  if (sameOwned(currentOwned, contract.original)) {
+    return {
+      kind: "done",
+      note: contract.original.at === "absent" ? `${path}: the ai-erd block is already gone.` : `${path}: the ai-erd block that was there before is already back in place.`
+    };
+  }
+  if (current === void 0 && contract.original.at === "text") {
+    const body = existing.trim() ? `${existing.replace(/\s*$/, "")}
+
+${contract.original.text}
+` : `${contract.original.text}
+`;
+    return { kind: "write", content: body, note: `${path}: restored the ai-erd block that was there before.` };
+  }
+  if (!sameOwned(currentOwned, contract.written)) {
+    return {
+      kind: "unresolved",
+      note: `${path}: the ai-erd block was edited after init \u2014 left in place. Remove the block by hand if you meant to, then run --undo again.`
+    };
+  }
+  let result;
+  try {
+    result = contract.original.at === "text" ? { content: replaceMarkerBlockWith(existing, contract.original.text), removed: true, emptied: false } : removeMarkerBlock(existing);
+  } catch (error) {
+    return { kind: "unresolved", note: `${path}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (!result.removed) {
+    return {
+      kind: "unresolved",
+      note: `${path}: the ai-erd block could not be removed \u2014 it is still in the file. Remove it by hand, then run --undo again.`
+    };
+  }
+  if (result.emptied && contract.createdByUs) {
+    return { kind: "delete" };
+  }
+  return {
+    kind: "write",
+    content: result.content,
+    note: contract.original.at === "text" ? `${path}: restored the ai-erd block that was there before.` : void 0
+  };
+}
+function undoWhole(path, contract, existing) {
+  if (sameOwned(ownedText(existing), contract.original)) {
+    return { kind: "done", note: `${path} is already the file that existed before init.` };
+  }
+  if (!sameOwned(ownedText(existing), contract.written)) {
+    if (contract.original.at === "text") {
+      return {
+        kind: "unresolved",
+        note: `${path} was edited after init \u2014 left in place instead of restoring the pre-init file. The backup is kept; run --undo again once you have resolved it.`
+      };
+    }
+    return { kind: "keep", note: `${path} was edited after init \u2014 left in place instead of deleting it.` };
+  }
+  if (contract.original.at === "text") {
+    return {
+      kind: "write",
+      content: contract.original.text,
+      note: `${path}: restored the file that existed before init.`
+    };
+  }
+  return contract.createdByUs ? { kind: "delete" } : { kind: "done" };
+}
+function undoFields(path, contract, existing) {
+  const parsed = parseJsonObject(existing);
+  if (parsed === void 0) {
+    return {
+      kind: "unresolved",
+      note: `${path} is not a JSON object any more, so ai-erd could not take its fields back out \u2014 the backup is kept. Fix the file and run --undo again.`
+    };
+  }
+  const contractProblem = fieldsContractProblem(contract, OUR_CONFIG_FIELDS);
+  if (contractProblem !== void 0) {
+    return {
+      kind: "unresolved",
+      note: `${path}: ai-erd's record of the fields it wrote ${contractProblem}, so its fields were left in place \u2014 the backup is kept. Restore that record, or remove the fields by hand.`
+    };
+  }
+  const written = contract.writtenFields;
+  const originals = contract.originalFields;
+  const next = {};
+  const kept = [];
+  for (const [field, value] of Object.entries(parsed)) {
+    if (!OUR_CONFIG_FIELDS.includes(field)) {
+      next[field] = value;
+      continue;
+    }
+    if (!hasField(written, field)) {
+      return {
+        kind: "unresolved",
+        note: `${path}: ai-erd has no record of what it wrote for ${field}, so its fields were left in place \u2014 the backup is kept. Restore that record, or remove the field by hand.`
+      };
+    }
+    const stillOurs = stableStringify(value) === stableStringify(written[field]);
+    if (!stillOurs) {
+      next[field] = value;
+      kept.push(field);
+      continue;
+    }
+    const original = originals[field];
+    if (original === void 0 || original.at !== "json" && original.at !== "absent") {
+      return {
+        kind: "unresolved",
+        note: `${path}: ai-erd cannot tell what was in ${field} before it wrote there, so the file was left as it is \u2014 the backup is kept. Remove the field by hand if you meant to.`
+      };
+    }
+    if (original.at === "json") {
+      next[field] = original.value;
+    }
+  }
+  const note = kept.length === 0 ? void 0 : `${path}: you changed ${kept.join(", ")} after init \u2014 left as you set it instead of putting the pre-init value back.`;
+  if (Object.keys(next).length === 0 && contract.createdByUs) {
+    return { kind: "delete", note };
+  }
+  const body = serialize(next);
+  return body === existing ? { kind: "done", note } : {
+    kind: "write",
+    content: body,
+    note: note ?? `${path}: removed what ai-erd wrote and kept the rest.`
+  };
+}
+function withCreatedDirectories(current, directories) {
+  const state = readRecord(current);
+  if (state.state !== "valid") {
+    return current;
+  }
+  return serializeRecord({ ...state.record, createdDirectories: [...directories] });
+}
+function parentsOf(paths) {
+  const directories = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const parent = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+    if (parent) {
+      directories.add(parent);
+    }
+  }
+  return [...directories].sort((left, right) => right.length - left.length);
+}
+function detectRoles(files) {
+  const found = /* @__PURE__ */ new Map();
+  for (const target of AGENT_TARGETS) {
+    const existing = files.get(target.path);
+    if (existing === void 0) {
+      continue;
+    }
+    found.set(target.path, previousRole(existing));
+  }
+  return found;
+}
+function previousRole(existing) {
+  if (existing === void 0) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(existing);
+    return readRoleFromEntry(parsed.mcpServers?.[SERVER_NAME]);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/harness/documentFetch.ts
+var DOC_KEY2 = "HARNESS.DOC";
+var AGENT_NOTE_KEY2 = "HARNESS.AGENT_NOTE";
+async function fetchHarnessDocuments(input) {
+  const url = new URL(`${input.endpoint.replace(/\/$/, "")}/harness/documents`);
+  assertTrustedEndpointUrl(url, "harness documents URL");
+  if (input.client) {
+    url.searchParams.set("client", input.client);
+  }
+  const fetchImpl = input.fetchImpl ?? fetch;
+  try {
+    const response = await fetchImpl(url.toString(), {
+      headers: {
+        accept: "application/json",
+        ...input.accessToken ? { authorization: `Bearer ${input.accessToken}` } : {}
+      }
+    });
+    if (!response.ok) {
+      return { versions: {}, fallbacks: {}, unavailableReason: `server answered HTTP ${response.status}` };
+    }
+    const payload = await response.json();
+    const documents = payload.documents ?? {};
+    const versions = {};
+    const fallbacks = {};
+    const bodies = {};
+    for (const key of [DOC_KEY2, AGENT_NOTE_KEY2]) {
+      const entry = documents[key];
+      const problem = usableBodyProblem(key, entry);
+      if (problem) {
+        fallbacks[key] = typeof entry?.reason === "string" && entry.reason ? entry.reason : problem;
+        continue;
+      }
+      bodies[key] = entry.body;
+      if (typeof entry?.version === "string") {
+        versions[key] = entry.version;
+      }
+    }
+    return { doc: bodies[DOC_KEY2], agentNote: bodies[AGENT_NOTE_KEY2], versions, fallbacks };
+  } catch (error) {
+    return {
+      versions: {},
+      fallbacks: {},
+      unavailableReason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function usableBodyProblem(key, entry) {
+  if (typeof entry?.body !== "string" || !entry.body.trim()) {
+    return `server returned no body for ${key}`;
+  }
+  return documentContractProblem(key, entry.body);
+}
+
+// src/adapters/cli/initCommand.ts
+async function executeInitCommand(options) {
+  const args = parseInitArgs(options.argv);
+  const root = resolve(options.cwd);
+  const files = await readSnapshot(root);
+  if (args.undo) {
+    const plan2 = planUndo({ files });
+    await applyPlan(root, plan2, args.dryRun, files, false);
+    options.io.stdout.write(renderSuccess(
+      {
+        action: args.dryRun ? "undo (dry-run)" : "undo",
+        updated: plan2.writes.map((write) => write.path),
+        removed: plan2.deletes,
+        notes: plan2.notes
+      },
+      { json: options.json }
+    ));
+    return 0;
+  }
+  const role = options.role ?? currentRole(files);
+  if (!role) {
+    throw new Error(
+      `--role is required on first run. Pick one of: ${HARNESS_ROLES.join(", ")}.`
+    );
+  }
+  const refusal = initRefusal(files);
+  if (refusal !== void 0) {
+    throw new Error(refusal);
+  }
+  const project = await resolveProject(options, args, files, root);
+  if ("choices" in project) {
+    options.io.stdout.write(renderSuccess(
+      {
+        message: "More than one project found. Re-run with --project <uuid>.",
+        projects: project.choices
+      },
+      { json: options.json }
+    ));
+    return 1;
+  }
+  const documents = args.dryRun ? { versions: {}, fallbacks: {}, unavailableReason: "skipped in --dry-run" } : await fetchHarnessDocuments({
+    endpoint: options.endpoint,
+    accessToken: await options.accessToken?.(),
+    client: "ai-erd-cli",
+    fetchImpl: options.fetchImpl
+  });
+  const plan = planInit({
+    role,
+    env: options.env,
+    projectName: project.name,
+    projectUuid: project.uuid,
+    endpoint: options.endpoint,
+    cliVersion: options.cliVersion,
+    files,
+    documents
+  });
+  if (plan.refusal !== void 0) {
+    throw new Error(plan.refusal);
+  }
+  await applyPlan(root, plan, args.dryRun, files);
+  options.io.stdout.write(renderSuccess(
+    {
+      action: args.dryRun ? "init (dry-run)" : "init",
+      role,
+      project: { uuid: project.uuid, name: project.name },
+      endpoint: options.endpoint,
+      written: plan.writes.map((write) => `${write.existed ? "updated" : "created"} ${write.path}`),
+      codex: `Codex keeps a single global config, so init does not touch it. Run: ${plan.codexCommand}`,
+      codexPerSession: plan.codexProfile,
+      codexEnvFallback: `Without a profile, start the session with ${ROLE_ENV_VAR}=${role}.`,
+      // ⚠조용히 기본값으로 떨어지지 않는다 — 서버에서 규칙을 고쳐도 안 바뀌는 이유를
+      //   사용자가 영영 못 찾게 된다. ★요청 자체의 실패와 «문서별» 되돌림을 둘 다 적는다
+      //   (2026-09-23 독립 재리뷰 I5: HTTP 200 으로 온 빈 문서가 조용히 패키지 판이 됐다).
+      notes: [...plan.notes, ...fallbackNotes(documents)],
+      next: [
+        "Restart the agent so it picks up the new MCP server.",
+        role === "design" ? "Ask it to change a table \u2014 a Design session may, and the change lands in AI-ERD." : `Ask it to change a table \u2014 a ${role} session will be told to stop.`,
+        `Enforce this on the server too: ${loginCommand(options, role)}`,
+        "Undo everything with: ai-erd init --undo"
+      ]
+    },
+    { json: options.json }
+  ));
+  return 0;
+}
+async function readRepositoryRole(cwd) {
+  const root = resolve(cwd);
+  const files = /* @__PURE__ */ new Map();
+  for (const target of AGENT_TARGETS) {
+    files.set(target.path, await readManagedFile(root, target.path));
+  }
+  try {
+    return currentRole(files);
+  } catch {
+    return void 0;
+  }
+}
+function currentRole(files) {
+  const found = [...detectRoles(files).values()].filter((role) => role !== void 0);
+  const unique = [...new Set(found)];
+  if (unique.length > 1) {
+    throw new Error(
+      `Agent configs disagree about the session role (${unique.join(", ")}). Re-run with an explicit --role to line them up.`
+    );
+  }
+  return unique[0];
+}
+function fallbackNotes(documents) {
+  const notes = [];
+  if (documents.unavailableReason) {
+    notes.push(`Harness rules came from this package, not the server (${documents.unavailableReason}).`);
+  }
+  for (const [key, reason] of Object.entries(documents.fallbacks)) {
+    notes.push(`${key} came from this package, not the server (${reason}).`);
+  }
+  return notes;
+}
+async function resolveProject(options, args, files, root) {
+  const projects = await listProjects(options);
+  if (args.projectUuid) {
+    const found = projects.find((project) => project.uuid === args.projectUuid);
+    return found ?? { uuid: args.projectUuid, name: args.projectName ?? args.projectUuid };
+  }
+  const bound = boundProjectUuid(files.get(HARNESS_CONFIG_PATH));
+  if (bound) {
+    const found = projects.find((project) => project.uuid === bound);
+    if (found) {
+      return found;
+    }
+  }
+  if (projects.length === 1) {
+    return projects[0];
+  }
+  if (projects.length > 1) {
+    return { choices: projects };
+  }
+  const name = args.projectName ?? basenameOf(root);
+  if (!args.yes) {
+    throw new Error(
+      `No project found in your AI-ERD account. Re-run with --yes to create "${name}", or --project-name <name> --yes to pick the name.`
+    );
+  }
+  if (args.dryRun) {
+    throw new Error(
+      `--dry-run cannot continue: there is no project to bind, and creating "${name}" would be a real change. Re-run without --dry-run, or pass --project <uuid>.`
+    );
+  }
+  return createProject(options, name);
+}
+async function listProjects(options) {
+  const result = await callOrExplainSignIn(options, () => options.client.toolsCall("list_projects", {}));
+  return extractProjects(unwrapToolJson(result));
+}
+async function callOrExplainSignIn(options, run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (!isUnauthorized(error)) {
+      throw error;
+    }
+    throw new Error(
+      `Not signed in for this role, so ${options.endpoint} refused the request (HTTP 401).
+
+    ${loginCommand(options, options.role)}
+
+Then run init again. The role is carried by the access token, so each role signs in once.`
+    );
+  }
+}
+function loginCommand(options, role) {
+  const target = isDefaultEndpointFor(options.env, options.endpoint) ? options.env === "prod" ? "" : ` --env ${options.env}` : ` --endpoint ${options.endpoint}`;
+  return `ai-erd auth login --role ${role ?? "<design|development|test|validation>"}${target}`;
+}
+function isUnauthorized(error) {
+  return error instanceof McpRpcError && error.code === "MCP_HTTP_ERROR" && error.details?.status === 401;
+}
+async function createProject(options, name) {
+  const result = await callOrExplainSignIn(options, () => options.client.toolsCall("create_projects", { items: [{ name }] }));
+  const created = extractProjects(unwrapToolJson(result));
+  const first = created[0];
+  if (!first) {
+    throw new Error("Project creation did not return a project uuid.");
+  }
+  return first;
+}
+function unwrapToolJson(result) {
+  if (!isRecord8(result) || !Array.isArray(result.content)) {
+    return result;
+  }
+  const first = result.content.find((item) => isRecord8(item) && item.type === "text");
+  if (!isRecord8(first) || typeof first.text !== "string") {
+    return result;
+  }
+  try {
+    return JSON.parse(first.text);
+  } catch {
+    return first.text;
+  }
+}
+function extractProjects(value) {
+  const candidates = Array.isArray(value) ? value : isRecord8(value) ? ["projects", "items", "created", "data", "hits"].flatMap((key) => {
+    const nested = value[key];
+    return Array.isArray(nested) ? nested : [];
+  }) : [];
+  const projects = [];
+  for (const candidate of candidates) {
+    if (isRecord8(candidate) && typeof candidate.uuid === "string") {
+      projects.push({
+        uuid: candidate.uuid,
+        name: typeof candidate.name === "string" ? candidate.name : candidate.uuid
+      });
+    }
+  }
+  return projects;
+}
+function boundProjectUuid(config) {
+  if (!config) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(config);
+    return typeof parsed.project?.uuid === "string" ? parsed.project.uuid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readSnapshot(root) {
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const path of MANAGED_PATHS) {
+    snapshot.set(path, await readManagedFile(root, path));
+  }
+  return snapshot;
+}
+async function readManagedFile(root, path) {
+  await assertInsideRepository(root, path);
+  return readIfExists(join2(root, path));
+}
+async function readIfExists(absolutePath) {
+  try {
+    return await readFile4(absolutePath, "utf8");
+  } catch (error) {
+    if (isRecord8(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function assertInsideRepository(root, relativePath) {
+  const absolutePath = join2(root, relativePath);
+  const realRoot = await realpath(root);
+  let realParent;
+  try {
+    realParent = await realpath(dirname2(absolutePath));
+  } catch (error) {
+    if (isRecord8(error) && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  if (realParent !== realRoot && !realParent.startsWith(realRoot + sep)) {
+    throw new Error(
+      `${relativePath} resolves outside the repository (${realParent}); refusing to touch it.`
+    );
+  }
+  try {
+    if ((await lstat(absolutePath)).isSymbolicLink()) {
+      throw new Error(`${relativePath} is a symbolic link; refusing to write through it.`);
+    }
+  } catch (error) {
+    if (!isRecord8(error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function applyPlan(root, plan, dryRun, snapshot, recordFirst = true) {
+  for (const write of plan.writes) {
+    await assertInsideRepository(root, write.path);
+    await assertUnchangedSinceSnapshot(root, write.path, snapshot);
+  }
+  for (const path of plan.deletes) {
+    await assertInsideRepository(root, path);
+    await assertUnchangedSinceSnapshot(root, path, snapshot);
+  }
+  if (dryRun) {
+    return;
+  }
+  const applied = [];
+  try {
+    const isRecord9 = (path) => !recordFirst && path === HARNESS_RECORD_PATH;
+    const recordWrites = plan.writes.filter((write) => isRecord9(write.path));
+    const recordDeletes = plan.deletes.filter((path) => isRecord9(path));
+    const createdDirectories = [...plan.record?.createdDirectories ?? []];
+    const rememberDirectories = (directories) => {
+      for (const directory of directories) {
+        if (!createdDirectories.includes(directory)) {
+          createdDirectories.push(directory);
+        }
+      }
+    };
+    const recordActualDirectories = async () => {
+      const write = plan.writes.find((w) => w.path === HARNESS_RECORD_PATH);
+      if (!recordFirst || !plan.record || !write || !applied.includes(HARNESS_RECORD_PATH)) {
+        return;
+      }
+      await writeManagedFile(root, {
+        ...write,
+        content: withCreatedDirectories(write.content, createdDirectories)
+      });
+    };
+    const recordDirectoriesOrExplain = async (failing) => {
+      try {
+        await recordActualDirectories();
+      } catch (error) {
+        if (!failing) {
+          throw error;
+        }
+      }
+    };
+    const apply = async (writes, deletes) => {
+      for (const write of writes) {
+        await assertUnchangedSinceSnapshot(root, write.path, snapshot);
+        await writeManagedFile(root, write, rememberDirectories);
+        applied.push(write.path);
+      }
+      for (const path of deletes) {
+        await assertUnchangedSinceSnapshot(root, path, snapshot);
+        await rm2(join2(root, path), { force: true });
+        applied.push(path);
+      }
+    };
+    try {
+      await apply(
+        orderedWrites(plan.writes.filter((write) => !isRecord9(write.path)), recordFirst),
+        plan.deletes.filter((path) => !isRecord9(path))
+      );
+      await recordDirectoriesOrExplain(false);
+      await apply(recordWrites, recordDeletes);
+    } catch (error) {
+      await recordDirectoriesOrExplain(true);
+      throw error;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `${message}
+Already applied before this failure: ${applied.join(", ") || "(nothing)"}`
+    );
+  }
+  for (const directory of plan.removableDirectories ?? []) {
+    await rmdir(join2(root, directory)).catch(() => void 0);
+  }
+}
+function orderedWrites(writes, recordFirst) {
+  const record = writes.filter((write) => write.path === HARNESS_RECORD_PATH);
+  const rest = writes.filter((write) => write.path !== HARNESS_RECORD_PATH);
+  return recordFirst ? [...record, ...rest] : [...rest, ...record];
+}
+async function assertUnchangedSinceSnapshot(root, relativePath, snapshot) {
+  if (!snapshot.has(relativePath)) {
+    return;
+  }
+  const now = await readIfExists(join2(root, relativePath));
+  if (now !== snapshot.get(relativePath)) {
+    throw new Error(
+      `${relativePath} changed while init was running; nothing was written. Run init again.`
+    );
+  }
+}
+async function writeManagedFile(root, write, onDirectoriesCreated) {
+  const absolutePath = join2(root, write.path);
+  const targetDirectory = dirname2(absolutePath);
+  const firstCreated = await mkdir2(targetDirectory, { recursive: true });
+  const created = createdChain(root, firstCreated, targetDirectory);
+  onDirectoriesCreated?.(created);
+  const previousMode = await fileMode(absolutePath);
+  const tmpPath = `${absolutePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile2(tmpPath, write.content, { encoding: "utf8", mode: previousMode ?? 384 });
+  if (previousMode !== void 0) {
+    await chmod2(tmpPath, previousMode);
+  }
+  await rename2(tmpPath, absolutePath);
+  return created;
+}
+function createdChain(root, firstCreated, targetDirectory) {
+  if (firstCreated === void 0) {
+    return [];
+  }
+  const stop = resolve(firstCreated);
+  const made = [];
+  for (let at = resolve(targetDirectory); ; at = dirname2(at)) {
+    const asRelative = relative(root, at);
+    if (asRelative && !asRelative.startsWith("..")) {
+      made.push(asRelative.split(sep).join("/"));
+    }
+    if (at === stop || dirname2(at) === at) {
+      break;
+    }
+  }
+  return made;
+}
+async function fileMode(absolutePath) {
+  try {
+    return (await stat3(absolutePath)).mode & 4095;
+  } catch (error) {
+    if (isRecord8(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function parseInitArgs(argv) {
+  const args = { dryRun: false, undo: false, yes: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--project") {
+      args.projectUuid = requireValue3(arg, argv[++index]);
+    } else if (arg === "--project-name") {
+      args.projectName = requireValue3(arg, argv[++index]);
+    } else if (arg === "--dry-run") {
+      args.dryRun = true;
+    } else if (arg === "--undo") {
+      args.undo = true;
+    } else if (arg === "--yes" || arg === "-y") {
+      args.yes = true;
+    } else if (arg === "--json") {
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return args;
+}
+function requireValue3(flag, value) {
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+function basenameOf(path) {
+  const parts = path.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? "ai-erd-project";
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/version.ts
+var CLI_VERSION = true ? "0.3.0" : "dev";
+var CLI_USER_AGENT = `@ai-erd/mcp ${CLI_VERSION}`;
+
+// src/adapters/cli/ainectoCli.ts
+async function runAinectoCli(argv, io) {
+  let parsed = { json: argv.includes("--json"), help: false, positionals: [] };
+  try {
+    parsed = parseGlobalArgs(argv);
+    if (parsed.help || parsed.positionals.length === 0) {
+      io.stdout.write(helpText());
+      return 0;
+    }
+    const resolved = resolveEndpoint({ env: parsed.env, endpoint: parsed.endpoint });
+    let sessionRole = resolveRole({ role: parsed.role }).role;
+    if (parsed.positionals[0] === "init" && sessionRole === void 0 && !argv.includes("--undo")) {
+      sessionRole = await readRepositoryRole(process.cwd());
+    }
+    const tokenStore = new FileTokenStore();
+    const auth = new OAuthClient({ endpoint: resolved.endpoint, tokenStore, role: sessionRole });
+    const client = new McpRpcClient({
+      endpoint: resolved.endpoint,
+      tokenProvider: auth,
+      role: sessionRole
+    });
+    const [domain, action, ...rest] = parsed.positionals;
+    if (domain === "mcp") {
+      await runConnector({
+        endpoint: resolved.endpoint,
+        // `ai-erd mcp` 로 붙는 경로도 같은 역할을 쓴다 — bin/mcp.ts 와 같은 규칙.
+        role: sessionRole,
+        input: io.stdin,
+        output: io.stdout,
+        errorOutput: io.stderr
+      });
+      return 0;
+    }
+    if (domain === "init") {
+      return await executeInitCommand({
+        argv: parsed.positionals.slice(1),
+        role: sessionRole,
+        // 문서는 인증 후에 받는다 — 토큰이 없으면 패키지 기본값으로 가고, 그 사실을 보고한다.
+        // ★«필요할 때» 가져온다. --undo 는 로컬 작업이라 토큰을 건드릴 이유가 없다(S1).
+        accessToken: () => auth.getAccessToken().catch(() => void 0),
+        client,
+        endpoint: resolved.endpoint,
+        env: resolved.env,
+        cliVersion: `@ai-erd/mcp ${CLI_VERSION}`,
+        cwd: process.cwd(),
+        json: parsed.json,
+        io
+      });
+    }
+    if (domain === "auth") {
+      return await handleAuth(action, auth, resolved.endpoint, parsed.json, io);
+    }
+    if (isAttachmentsUploadCommand(domain, action)) {
+      return await executeAttachmentsUploadCommand({
+        argv: rest,
+        client,
+        json: parsed.json,
+        io
+      });
+    }
+    const generatedResult = await executeGeneratedCommand({
+      env: parsed.env ?? "prod",
+      argv: parsed.positionals,
+      client,
+      json: parsed.json,
+      io
+    });
+    if (generatedResult !== 2) {
+      return generatedResult;
+    }
+    if (domain === "tools") {
+      return await handleTools(action, rest, parsed, client, io);
+    }
+    throw new Error(`Unknown command "${domain}".`);
+  } catch (error) {
+    io.stderr.write(renderError(error, { json: parsed.json }));
+    return 1;
+  }
+}
+async function handleAuth(action, auth, endpoint, json, io) {
+  if (action === "login") {
+    await auth.login();
+    io.stdout.write(renderSuccess({ endpoint, authenticated: true }, { json }));
+    return 0;
+  }
+  if (action === "status") {
+    const token = await auth.getAccessToken();
+    io.stdout.write(renderSuccess({ endpoint, authenticated: Boolean(token) }, { json }));
+    return 0;
+  }
+  if (action === "logout") {
+    await auth.logout();
+    io.stdout.write(renderSuccess({ endpoint, authenticated: false }, { json }));
+    return 0;
+  }
+  throw new Error("Expected auth login, auth status, or auth logout.");
+}
+async function handleTools(action, rest, parsed, client, io) {
+  if (action === "list") {
+    const tools = await client.toolsList();
+    io.stdout.write(renderSuccess(tools, { json: parsed.json }));
+    return 0;
+  }
+  if (action === "call") {
+    const toolName = rest[0];
+    if (!toolName) {
+      throw new Error("Expected MCP tool name after tools call.");
+    }
+    const toolArgs = rest.slice(1);
+    const payloadOptions = parsePayloadArgs(toolArgs);
+    const payload = await parsePayloadSource({
+      file: payloadOptions.file,
+      inline: payloadOptions.inline,
+      stdin: io.stdin
+    });
+    const result = await client.toolsCall(toolName, payload.value);
+    io.stdout.write(renderSuccess(result, { json: parsed.json, warnings: payload.warnings }));
+    return isToolError(result) ? 1 : 0;
+  }
+  if (action === "catalog") {
+    const catalogEnv = parsed.env ?? "prod";
+    io.stdout.write(renderSuccess(getGeneratedTools(parsed.env ?? "prod"), {
+      json: parsed.json,
+      warnings: [catalogEnv === "dev" ? "Local dev catalog is a checked-in live sync snapshot; rerun sync:tools --env dev to refresh it." : "Local prod catalog is seed fixture only until authenticated prod live sync updates generated catalogs."]
+    }));
+    return 0;
+  }
+  throw new Error("Expected tools list, tools call <mcpName>, or tools catalog.");
+}
+function parseGlobalArgs(argv) {
+  const result = { json: false, help: false, positionals: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--env") {
+      result.env = assertEnv(requireValue4(arg, argv[++index]));
+    } else if (arg === "--endpoint") {
+      result.endpoint = requireValue4(arg, argv[++index]);
+    } else if (arg === "--role") {
+      result.role = assertRole(requireValue4(arg, argv[++index]));
+    } else if (arg === "--json") {
+      result.json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else {
+      result.positionals.push(arg);
+    }
+  }
+  return result;
+}
+function parsePayloadArgs(argv) {
+  const result = {};
+  const inline = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--file" || arg === "-f") {
+      result.file = requireValue4(arg, argv[++index]);
+    } else {
+      inline.push(arg);
+    }
+  }
+  if (inline.length > 0) {
+    result.inline = inline.join(" ");
+  }
+  return result;
+}
+function requireValue4(flag, value) {
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+function helpText() {
+  return [
+    "Ainecto CLI",
+    "",
+    "Usage:",
+    "  ainecto auth login --role <design|development|test|validation> [--env prod|dev] [--json]",
+    "  ainecto auth status|logout [--role <role>] [--env prod|dev] [--json]",
+    "  ainecto tools list [--env prod|dev] [--endpoint URL] [--json]",
+    "  ainecto tools call <mcpName> [-f payload.json|@-] [inline-json] [--json]",
+    "  ainecto attachments upload --document-uuid <uuid> <file...> [--json]",
+    "  ainecto <generated-command> [flags] [-f payload.json] [--yes] [--json]",
+    "  ainecto mcp [--env prod|dev] [--endpoint URL] [--role design|development|test|validation]",
+    "",
+    "Harness:",
+    "  ai-erd init --role <design|development|test|validation> [--project <uuid>] [--dry-run]",
+    "  ai-erd init --undo",
     ""
   ].join("\n");
 }