@wport/cli 0.7.0 → 0.8.0

package/dist/index.js

@@ -179,7 +179,7 @@ function isTimeoutAbort(err) {
   return false;
 }
 function buildUserAgent() {
-  return `wport-cli/${"0.7.0"} (node ${process.version}; ${process.platform})`;
+  return `wport-cli/${"0.8.0"} (node ${process.version}; ${process.platform})`;
 }
 function unwrapDataResponse(body) {
   if (body && typeof body === "object" && "success" in body && "data" in body) {
@@ -970,7 +970,269 @@ function registerConfigCommand(program2) {
 }
 
 // src/commands/doctor.ts
+var import_node_fs6 = require("fs");
+
+// src/lib/credentials-store.ts
 var import_node_fs5 = require("fs");
+var import_node_path2 = require("path");
+var import_env_paths2 = __toESM(require("env-paths"));
+var API_KEY_ENV_VAR = "WPORT_API_KEY";
+var KEY_PREFIX = "wpk_live_";
+var KEY_MIN_LENGTH = KEY_PREFIX.length + 32;
+var paths2 = (0, import_env_paths2.default)("wport", { suffix: "" });
+function getCredentialsPath() {
+  return (0, import_node_path2.join)(paths2.config, "credentials.json");
+}
+function isValidKeyFormat(key) {
+  return key.startsWith(KEY_PREFIX) && key.length >= KEY_MIN_LENGTH && !/\s/.test(key);
+}
+function maskKey(key) {
+  return `${KEY_PREFIX}\u2022\u2022\u2022\u2022${key.slice(-4)}`;
+}
+function readRawFile(strict) {
+  const path = getCredentialsPath();
+  if (!(0, import_node_fs5.existsSync)(path)) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
+  } catch (err) {
+    if (!strict) return {};
+    throw new CliError(
+      `Failed to read credentials at ${path}: ${err.message}. Run "wport enterprise login" to recreate it.`,
+      ExitCode.ConfigCorrupt
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    if (!strict) return {};
+    throw new CliError(
+      `Credentials file at ${path} is malformed. Run "wport enterprise login" to recreate it.`,
+      ExitCode.ConfigCorrupt
+    );
+  }
+  const raw = parsed;
+  if (typeof raw.api_key === "string") {
+    return { enterprise: raw };
+  }
+  return { enterprise: raw.enterprise, personal: raw.personal };
+}
+function parseEnterpriseCredentials(raw) {
+  const path = getCredentialsPath();
+  if (!raw || typeof raw !== "object" || typeof raw.api_key !== "string") {
+    throw new CliError(
+      `Credentials file at ${path} is malformed. Run "wport enterprise login" to recreate it.`,
+      ExitCode.ConfigCorrupt
+    );
+  }
+  const r = raw;
+  const apiKey = r.api_key;
+  return {
+    api_key: apiKey,
+    company_name: typeof r.company_name === "string" ? r.company_name : "",
+    key_last4: typeof r.key_last4 === "string" ? r.key_last4 : apiKey.slice(-4),
+    saved_at: typeof r.saved_at === "string" ? r.saved_at : ""
+  };
+}
+function parsePersonalCredentials(raw) {
+  const path = getCredentialsPath();
+  if (!raw || typeof raw !== "object" || typeof raw.access_token !== "string" || typeof raw.refresh_token !== "string" || typeof raw.expires_at !== "string") {
+    throw new CliError(
+      `Personal credentials at ${path} are malformed or incomplete. Run "wport login" to sign in again.`,
+      ExitCode.ConfigCorrupt
+    );
+  }
+  const r = raw;
+  return {
+    access_token: r.access_token,
+    refresh_token: r.refresh_token,
+    expires_at: r.expires_at,
+    display_name: typeof r.display_name === "string" ? r.display_name : "",
+    email: typeof r.email === "string" ? r.email : "",
+    session_created_at: typeof r.session_created_at === "string" ? r.session_created_at : ""
+  };
+}
+function writeFileAtomic0600(path, content) {
+  (0, import_node_fs5.mkdirSync)((0, import_node_path2.dirname)(path), { recursive: true });
+  const tmpPath = `${path}.tmp.${process.pid}.${Date.now()}`;
+  const fd = (0, import_node_fs5.openSync)(tmpPath, "w", 384);
+  try {
+    (0, import_node_fs5.writeSync)(fd, content);
+  } catch (err) {
+    (0, import_node_fs5.closeSync)(fd);
+    try {
+      (0, import_node_fs5.unlinkSync)(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  (0, import_node_fs5.closeSync)(fd);
+  if (process.platform !== "win32") {
+    try {
+      (0, import_node_fs5.chmodSync)(tmpPath, 384);
+    } catch (err) {
+      printWarn(
+        `Failed to chmod 0600 on credentials tmpfile: ${err.message}. Other users on this system may be able to read your API key.`,
+        false
+      );
+    }
+  }
+  (0, import_node_fs5.renameSync)(tmpPath, path);
+}
+function writeCredentialsFile(file) {
+  const body = { version: 2 };
+  if (file.enterprise !== void 0) body.enterprise = file.enterprise;
+  if (file.personal !== void 0) body.personal = file.personal;
+  writeFileAtomic0600(getCredentialsPath(), JSON.stringify(body, null, 2) + "\n");
+}
+function loadCredentials() {
+  const { enterprise } = readRawFile(true);
+  if (enterprise === void 0) return null;
+  return parseEnterpriseCredentials(enterprise);
+}
+function saveCredentials(creds) {
+  const { personal } = readRawFile(false);
+  writeCredentialsFile({ enterprise: creds, personal });
+}
+function deleteCredentials() {
+  const path = getCredentialsPath();
+  if (!(0, import_node_fs5.existsSync)(path)) return false;
+  const { enterprise, personal } = readRawFile(false);
+  if (enterprise === void 0 && personal === void 0) {
+    (0, import_node_fs5.unlinkSync)(path);
+    return true;
+  }
+  if (enterprise === void 0) return false;
+  if (personal === void 0) {
+    (0, import_node_fs5.unlinkSync)(path);
+  } else {
+    writeCredentialsFile({ personal });
+  }
+  return true;
+}
+function loadPersonalCredentials() {
+  const { personal } = readRawFile(true);
+  if (personal === void 0) return null;
+  return parsePersonalCredentials(personal);
+}
+function savePersonalCredentials(p) {
+  const { enterprise } = readRawFile(false);
+  writeCredentialsFile({ enterprise, personal: p });
+}
+function deletePersonalCredentials() {
+  const { enterprise, personal } = readRawFile(false);
+  if (personal === void 0) return false;
+  writeCredentialsFile({ enterprise });
+  return true;
+}
+function resolveApiKey(flagValue) {
+  if (flagValue !== void 0) {
+    ensureFormat(flagValue, "--api-key");
+    return { key: flagValue, source: "flag" };
+  }
+  const fromEnv = process.env[API_KEY_ENV_VAR]?.trim();
+  if (fromEnv) {
+    ensureFormat(fromEnv, `${API_KEY_ENV_VAR} env var`);
+    return { key: fromEnv, source: "env" };
+  }
+  const creds = loadCredentials();
+  if (creds) return { key: creds.api_key, source: "file" };
+  throw new CliError(
+    `No API key found. Run "wport enterprise login" or set the ${API_KEY_ENV_VAR} env var.`,
+    ExitCode.InvalidArgument
+  );
+}
+function ensureFormat(key, source) {
+  if (!isValidKeyFormat(key)) {
+    throw new CliError(`API key from ${source} is not a valid ${KEY_PREFIX} key`, ExitCode.InvalidArgument);
+  }
+}
+
+// src/lib/personal-types.ts
+var PERSONAL_RESUMES_BASE = "/api/v1/personal/resumes";
+var OAUTH_BASE = "/api/oauth";
+var OAUTH_SESSIONS_BASE = `${OAUTH_BASE}/sessions`;
+var SECTION_WRITE_PLAN = {
+  education: { kind: "per-item-post", path: "/education" },
+  work_experience: { kind: "work-experience", path: "/work-experience" },
+  certificate: { kind: "per-item-post", path: "/certificate" },
+  language: { kind: "per-item-post", path: "/language" },
+  professional_skills: { kind: "single-post", path: "/professional-skills" },
+  autobiography: { kind: "single-post", path: "/autobiography" },
+  job_condition: { kind: "single-post", path: "/job-condition" },
+  portfolio_links: { kind: "bulk-put", path: "/portfolio-links" },
+  background: { kind: "single-post", path: "/background" }
+};
+
+// src/lib/oauth.ts
+var EXPIRED_MESSAGE = "The device code expired before authorization completed. Run `wport login` to try again.";
+async function oauthPost(opts, path, body) {
+  const url = new URL(`${opts.baseUrl}${path}`);
+  const request = new Request(url, {
+    method: "POST",
+    headers: {
+      "Accept-Language": opts.locale,
+      "User-Agent": buildUserAgent(),
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const res = await fetchWithTimeout(request, opts.timeoutMs);
+  const respBody = await res.json().catch(() => null);
+  return { status: res.status, body: respBody };
+}
+function oauthErrorCode(body) {
+  if (body && typeof body === "object" && typeof body.error === "string") {
+    return body.error;
+  }
+  return null;
+}
+async function requestDeviceCode(opts, deviceName) {
+  const body = {};
+  if (deviceName) body.device_name = deviceName;
+  const { status, body: respBody } = await oauthPost(opts, `${OAUTH_BASE}/device/code`, body);
+  if (status < 200 || status >= 300) throwForHttpStatus(status, respBody);
+  return respBody;
+}
+async function pollForToken(opts, device, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+  let intervalSec = device.interval;
+  const deadline = Date.now() + device.expires_in * 1e3;
+  for (; ; ) {
+    const { status, body } = await oauthPost(opts, `${OAUTH_BASE}/token`, {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: device.device_code
+    });
+    if (status >= 200 && status < 300) return body;
+    const code = oauthErrorCode(body);
+    if (code === "slow_down") {
+      intervalSec += 5;
+    } else if (code === "access_denied") {
+      throw new CliError("Authorization was denied on the device.", ExitCode.ServerClientError);
+    } else if (code === "expired_token") {
+      throw new CliError(EXPIRED_MESSAGE, ExitCode.ServerClientError);
+    } else if (code !== "authorization_pending") {
+      throwForHttpStatus(status, body);
+    }
+    if (Date.now() >= deadline) throw new CliError(EXPIRED_MESSAGE, ExitCode.ServerClientError);
+    await sleep(intervalSec * 1e3);
+  }
+}
+async function refreshAccessToken(opts, refreshToken) {
+  const { status, body } = await oauthPost(opts, `${OAUTH_BASE}/token`, {
+    grant_type: "refresh_token",
+    refresh_token: refreshToken
+  });
+  if (status >= 200 && status < 300) return body;
+  if (oauthErrorCode(body) === "invalid_grant") {
+    throw new CliError("Your session is no longer valid. Run `wport login` to sign in again.", ExitCode.ServerClientError);
+  }
+  throwForHttpStatus(status, body);
+}
+async function revokeRefreshToken(opts, refreshToken) {
+  const { status, body } = await oauthPost(opts, `${OAUTH_BASE}/revoke`, { token: refreshToken });
+  if (status < 200 || status >= 300) throwForHttpStatus(status, body);
+}
+
+// src/commands/doctor.ts
 var SILENT_IGNORED_PARAMS = ["orderBy", "order"];
 var ENTERPRISE_TALENT_BOUNDARY_NOTES = [
   "`enterprise talents` covers your APPLIED pool only (list / view / respond).",
@@ -981,40 +1243,68 @@ var ENTERPRISE_TALENT_BOUNDARY_NOTES = [
 ];
 function registerDoctorCommand(program2) {
   program2.command("doctor").description(
-    "Diagnose CLI setup: resolved config, server reachability, schema fingerprint, and known server quirks."
+    "Diagnose CLI setup: resolved config, personal login state, server reachability, schema fingerprint, and known server quirks."
   ).action(async (_opts, command) => {
     const ctx = resolveContext(command);
-    const line = (s = "") => process.stdout.write(s + "\n");
-    line(`wport-cli ${"0.7.0"}`);
-    line(`  bundled schema fingerprint: ${"839e8a891dfb"}`);
-    line("");
-    line("Resolved configuration:");
-    line(`  API base URL: ${ctx.baseUrl}`);
-    line(`  locale:       ${ctx.locale}`);
-    line(`  timeout:      ${ctx.timeoutMs}ms`);
-    const cfgPath = getConfigPath();
-    line(`  config file:  ${cfgPath}${(0, import_node_fs5.existsSync)(cfgPath) ? "" : " (not present)"}`);
-    line("");
-    line("Server connectivity:");
-    const reachable = await probeServer(ctx, line);
-    line("");
-    line("Known server behaviours (read this before scripting an agent):");
-    line(
-      `  \u2022 Sort is server-controlled. These query params are silently ignored: ${SILENT_IGNORED_PARAMS.join(", ")}.`
-    );
-    line("  \u2022 jobs search sorts by publish date, or by relevance when --keyword is set.");
-    line("  \u2022 jobs view --batch caps parallelism (default 5, max 20) to stay friendly to the API.");
-    line("");
-    line("Enterprise talent scope (Enterprise API Key):");
-    for (const note of ENTERPRISE_TALENT_BOUNDARY_NOTES) line(`  \u2022 ${note}`);
-    line("");
-    line("Schema drift:");
-    line("  The fingerprint above identifies the OpenAPI contract this CLI was built against.");
-    line("  Automated drift detection needs a server-side schema-version endpoint, which is");
-    line("  not available yet \u2014 for now, compare fingerprints manually after a server release. [TODO]");
+    const reachable = await runDoctor(ctx);
     if (!reachable) process.exit(ExitCode.ServerOrNetworkError);
   });
 }
+async function runDoctor(ctx) {
+  const line = (s = "") => process.stdout.write(s + "\n");
+  line(`wport-cli ${"0.8.0"}`);
+  line(`  bundled schema fingerprint: ${"839e8a891dfb"}`);
+  line("");
+  line("Resolved configuration:");
+  line(`  API base URL: ${ctx.baseUrl}`);
+  line(`  locale:       ${ctx.locale}`);
+  line(`  timeout:      ${ctx.timeoutMs}ms`);
+  const cfgPath = getConfigPath();
+  line(`  config file:  ${cfgPath}${(0, import_node_fs6.existsSync)(cfgPath) ? "" : " (not present)"}`);
+  line("");
+  line("Personal account (OAuth):");
+  for (const l of describePersonalLoginLines()) line(`  ${l}`);
+  line("");
+  line("Server connectivity:");
+  const reachable = await probeServer(ctx, line);
+  await probeAuthServer(ctx, line);
+  line("");
+  line("Known server behaviours (read this before scripting an agent):");
+  line(
+    `  \u2022 Sort is server-controlled. These query params are silently ignored: ${SILENT_IGNORED_PARAMS.join(", ")}.`
+  );
+  line("  \u2022 jobs search sorts by publish date, or by relevance when --keyword is set.");
+  line("  \u2022 jobs view --batch caps parallelism (default 5, max 20) to stay friendly to the API.");
+  line("");
+  line("Enterprise talent scope (Enterprise API Key):");
+  for (const note of ENTERPRISE_TALENT_BOUNDARY_NOTES) line(`  \u2022 ${note}`);
+  line("");
+  line("Schema drift:");
+  line("  The fingerprint above identifies the OpenAPI contract this CLI was built against.");
+  line("  Automated drift detection needs a server-side schema-version endpoint, which is");
+  line("  not available yet \u2014 for now, compare fingerprints manually after a server release. [TODO]");
+  return reachable;
+}
+function describePersonalLoginLines() {
+  try {
+    const creds = loadPersonalCredentials();
+    if (!creds) return ["not logged in (run `wport login` to sign in)"];
+    const expiresAtMs = Date.parse(creds.expires_at);
+    if (Number.isNaN(expiresAtMs)) {
+      return [
+        "logged in",
+        `access token expiry is unreadable ("${creds.expires_at}") \u2014 try \`wport login --force\` to re-authenticate`
+      ];
+    }
+    const expired = expiresAtMs <= Date.now();
+    return [
+      "logged in",
+      expired ? `access token expired at ${creds.expires_at} (refreshes automatically on next request)` : `access token valid until ${creds.expires_at}`
+    ];
+  } catch (err) {
+    return [`personal credentials file appears corrupted: ${err instanceof Error ? err.message : String(err)}`];
+  }
+}
 async function probeServer(ctx, line) {
   try {
     const client = createApiClient({ baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs });
@@ -1030,6 +1320,16 @@ async function probeServer(ctx, line) {
     return false;
   }
 }
+var DOCTOR_PROBE_DEVICE_NAME = "wport doctor (connectivity check)";
+async function probeAuthServer(ctx, line) {
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  try {
+    await requestDeviceCode(opts, DOCTOR_PROBE_DEVICE_NAME);
+    line("  \u2713 auth server reachable (device code endpoint)");
+  } catch (err) {
+    line(`  ! auth server check failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 
 // src/lib/enterprise-client.ts
 var ENTERPRISE_PREFIX = "/api/v1/enterprise";
@@ -1124,107 +1424,6 @@ function warnIfRateLimitLow(headers) {
   }
 }
 
-// src/lib/credentials-store.ts
-var import_node_fs6 = require("fs");
-var import_node_path2 = require("path");
-var import_env_paths2 = __toESM(require("env-paths"));
-var API_KEY_ENV_VAR = "WPORT_API_KEY";
-var KEY_PREFIX = "wpk_live_";
-var KEY_MIN_LENGTH = KEY_PREFIX.length + 32;
-var paths2 = (0, import_env_paths2.default)("wport", { suffix: "" });
-function getCredentialsPath() {
-  return (0, import_node_path2.join)(paths2.config, "credentials.json");
-}
-function isValidKeyFormat(key) {
-  return key.startsWith(KEY_PREFIX) && key.length >= KEY_MIN_LENGTH && !/\s/.test(key);
-}
-function maskKey(key) {
-  return `${KEY_PREFIX}\u2022\u2022\u2022\u2022${key.slice(-4)}`;
-}
-function loadCredentials() {
-  const path = getCredentialsPath();
-  if (!(0, import_node_fs6.existsSync)(path)) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse((0, import_node_fs6.readFileSync)(path, "utf8"));
-  } catch (err) {
-    throw new CliError(
-      `Failed to read credentials at ${path}: ${err.message}. Run "wport enterprise login" to recreate it.`,
-      ExitCode.ConfigCorrupt
-    );
-  }
-  if (!parsed || typeof parsed !== "object" || typeof parsed.api_key !== "string") {
-    throw new CliError(
-      `Credentials file at ${path} is malformed. Run "wport enterprise login" to recreate it.`,
-      ExitCode.ConfigCorrupt
-    );
-  }
-  const raw = parsed;
-  const apiKey = raw.api_key;
-  return {
-    api_key: apiKey,
-    company_name: typeof raw.company_name === "string" ? raw.company_name : "",
-    key_last4: typeof raw.key_last4 === "string" ? raw.key_last4 : apiKey.slice(-4),
-    saved_at: typeof raw.saved_at === "string" ? raw.saved_at : ""
-  };
-}
-function saveCredentials(creds) {
-  const path = getCredentialsPath();
-  (0, import_node_fs6.mkdirSync)((0, import_node_path2.dirname)(path), { recursive: true });
-  const tmpPath = `${path}.tmp.${process.pid}.${Date.now()}`;
-  const fd = (0, import_node_fs6.openSync)(tmpPath, "w", 384);
-  try {
-    (0, import_node_fs6.writeSync)(fd, JSON.stringify(creds, null, 2) + "\n");
-  } catch (err) {
-    (0, import_node_fs6.closeSync)(fd);
-    try {
-      (0, import_node_fs6.unlinkSync)(tmpPath);
-    } catch {
-    }
-    throw err;
-  }
-  (0, import_node_fs6.closeSync)(fd);
-  if (process.platform !== "win32") {
-    try {
-      (0, import_node_fs6.chmodSync)(tmpPath, 384);
-    } catch (err) {
-      printWarn(
-        `Failed to chmod 0600 on credentials tmpfile: ${err.message}. Other users on this system may be able to read your API key.`,
-        false
-      );
-    }
-  }
-  (0, import_node_fs6.renameSync)(tmpPath, path);
-}
-function deleteCredentials() {
-  const path = getCredentialsPath();
-  if (!(0, import_node_fs6.existsSync)(path)) return false;
-  (0, import_node_fs6.unlinkSync)(path);
-  return true;
-}
-function resolveApiKey(flagValue) {
-  if (flagValue !== void 0) {
-    ensureFormat(flagValue, "--api-key");
-    return { key: flagValue, source: "flag" };
-  }
-  const fromEnv = process.env[API_KEY_ENV_VAR]?.trim();
-  if (fromEnv) {
-    ensureFormat(fromEnv, `${API_KEY_ENV_VAR} env var`);
-    return { key: fromEnv, source: "env" };
-  }
-  const creds = loadCredentials();
-  if (creds) return { key: creds.api_key, source: "file" };
-  throw new CliError(
-    `No API key found. Run "wport enterprise login" or set the ${API_KEY_ENV_VAR} env var.`,
-    ExitCode.InvalidArgument
-  );
-}
-function ensureFormat(key, source) {
-  if (!isValidKeyFormat(key)) {
-    throw new CliError(`API key from ${source} is not a valid ${KEY_PREFIX} key`, ExitCode.InvalidArgument);
-  }
-}
-
 // src/commands/enterprise/login.ts
 async function performLogin(ctx, key) {
   if (!isValidKeyFormat(key)) {
@@ -2493,13 +2692,1874 @@ function registerEnterpriseCommand(program2) {
   registerEnterpriseCampaignsCommand(enterprise);
 }
 
+// src/commands/auth/login.ts
+var import_node_os = require("os");
+
+// src/lib/browser-open.ts
+var import_node_child_process = require("child_process");
+function isSafeToOpen(url, platform) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+  if (platform === "win32" && /[&|^<>%"]/.test(url)) return false;
+  return true;
+}
+function commandFor(platform, url) {
+  switch (platform) {
+    case "darwin":
+      return { command: "open", args: [url] };
+    case "win32":
+      return { command: "cmd", args: ["/c", "start", '""', url] };
+    case "linux":
+      return { command: "xdg-open", args: [url] };
+    default:
+      return null;
+  }
+}
+function openInBrowser(url, spawnFn = import_node_child_process.spawn) {
+  if (!isSafeToOpen(url, process.platform)) return false;
+  const resolved = commandFor(process.platform, url);
+  if (!resolved) return false;
+  try {
+    const child = spawnFn(resolved.command, resolved.args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/auth/login.ts
+function describeIdentity(displayName, email) {
+  if (displayName && email) return `${displayName} (${email})`;
+  if (displayName) return displayName;
+  if (email) return email;
+  return "this device";
+}
+async function performLogin2(ctx, flags, deps = {}) {
+  const openBrowser = deps.openBrowser ?? openInBrowser;
+  const hostnameFn = deps.hostname ?? import_node_os.hostname;
+  if (!flags.force) {
+    const existing = loadPersonalCredentials();
+    if (existing) {
+      process.stdout.write(`Already logged in as ${describeIdentity(existing.display_name, existing.email)}.
+`);
+      process.stdout.write("Run `wport login --force` to sign in again.\n");
+      return;
+    }
+  }
+  const oauthOpts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const device = await requestDeviceCode(oauthOpts, hostnameFn());
+  process.stdout.write(`
+Enter this code when prompted:
+
+  ${device.user_code}
+
+`);
+  process.stdout.write(`Visit: ${device.verification_uri}
+`);
+  if (!flags.noBrowser && process.stdout.isTTY) {
+    const opened = openBrowser(device.verification_uri_complete);
+    if (!opened) {
+      process.stdout.write(`Open this URL manually: ${device.verification_uri_complete}
+`);
+    } else {
+      process.stdout.write(`Opened in your browser. If nothing appeared, visit: ${device.verification_uri_complete}
+`);
+    }
+  }
+  const tokens = await pollForToken(oauthOpts, device, deps.sleep);
+  const now = Date.now();
+  savePersonalCredentials({
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token,
+    expires_at: new Date(now + tokens.expires_in * 1e3).toISOString(),
+    display_name: "",
+    email: "",
+    session_created_at: new Date(now).toISOString()
+  });
+  process.stdout.write("Logged in.\n");
+}
+function registerLoginCommand(program2) {
+  program2.command("login").description("Sign in to your wport personal account (OAuth device authorization flow)").option("--no-browser", "do not try to open a browser automatically").option("--force", "sign in again even if already logged in").action(async (opts, command) => {
+    const ctx = resolveContext(command);
+    await performLogin2(ctx, { noBrowser: opts.browser === false, force: opts.force });
+  });
+}
+
+// src/lib/personal-client.ts
+var EXPIRY_SKEW_MS = 3e4;
+var NOT_LOGGED_IN_MESSAGE = "Not logged in. Run `wport login`.";
+async function ensureFreshCredentials(opts) {
+  const creds = loadPersonalCredentials();
+  if (!creds) throw new CliError(NOT_LOGGED_IN_MESSAGE, ExitCode.ServerClientError);
+  const msUntilExpiry = Date.parse(creds.expires_at) - Date.now();
+  if (msUntilExpiry >= EXPIRY_SKEW_MS) return creds;
+  return refreshAndSave(opts, creds);
+}
+async function refreshAndSave(opts, creds) {
+  const tokens = await refreshAccessToken(opts, creds.refresh_token);
+  const updated = {
+    ...creds,
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token,
+    expires_at: new Date(Date.now() + tokens.expires_in * 1e3).toISOString()
+  };
+  savePersonalCredentials(updated);
+  return updated;
+}
+async function attemptRequest(opts, method, path, accessToken, body, query, extra) {
+  const url = new URL(`${opts.baseUrl}${path}`);
+  for (const [k, v] of Object.entries(query ?? {})) {
+    if (v !== void 0) url.searchParams.set(k, String(v));
+  }
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Accept-Language": opts.locale,
+    "User-Agent": buildUserAgent(),
+    Accept: "application/json"
+  };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  if (extra?.idempotencyKey) headers["Idempotency-Key"] = extra.idempotencyKey;
+  const request = new Request(url, {
+    method,
+    headers,
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  const res = await fetchWithTimeout(request, opts.timeoutMs);
+  const respBody = await res.json().catch(() => null);
+  return { status: res.status, body: respBody, headers: res.headers };
+}
+async function personalRequest(opts, method, path, body, query, extra) {
+  const creds = await ensureFreshCredentials(opts);
+  let result = await attemptRequest(opts, method, path, creds.access_token, body, query, extra);
+  if (result.status === 401) {
+    const refreshed = await refreshAndSave(opts, creds);
+    result = await attemptRequest(opts, method, path, refreshed.access_token, body, query, extra);
+  }
+  if (result.status < 200 || result.status >= 300) throwPersonalHttpError(result.status, result.body);
+  warnIfRateLimitLow2(result.headers);
+  return { body: result.body, headers: result.headers };
+}
+function personalGet(opts, path, query) {
+  return personalRequest(opts, "GET", path, void 0, query, void 0);
+}
+function personalPost(opts, path, body, extra) {
+  return personalRequest(opts, "POST", path, body, void 0, extra);
+}
+function personalPatch(opts, path, body, extra) {
+  return personalRequest(opts, "PATCH", path, body, void 0, extra);
+}
+function personalPut(opts, path, body, extra) {
+  return personalRequest(opts, "PUT", path, body, void 0, extra);
+}
+function personalDelete(opts, path, extra) {
+  return personalRequest(opts, "DELETE", path, void 0, void 0, extra);
+}
+function throwPersonalHttpError(status, body) {
+  if (status === 401) {
+    const base = extractErrorMessage(body) ?? `HTTP ${status}`;
+    throw new CliError(
+      `${base} \u2014 Your session may have expired or the request was rejected. Run \`wport login\` to sign in again.`,
+      ExitCode.ServerClientError
+    );
+  }
+  throwForHttpStatus(status, body);
+}
+function warnIfRateLimitLow2(headers) {
+  const remaining = Number(headers.get("x-ratelimit-remaining"));
+  const limit = Number(headers.get("x-ratelimit-limit"));
+  if (Number.isFinite(remaining) && Number.isFinite(limit) && limit > 0 && remaining / limit < 0.1) {
+    printWarn(`Rate limit nearly exhausted: ${remaining}/${limit} requests remaining this window.`, false);
+  }
+}
+
+// src/commands/auth/whoami.ts
+var PLACEHOLDER = "\u2014";
+function display(value) {
+  const clean = sanitizeForTerminal(value ?? "");
+  return clean.length > 0 ? clean : PLACEHOLDER;
+}
+async function performWhoami(ctx) {
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const { body } = await personalGet(opts, OAUTH_SESSIONS_BASE);
+  const sessions = unwrapDataArray(body);
+  const current = sessions.find((s) => s.is_current);
+  const localLoginAt = loadPersonalCredentials()?.session_created_at ?? null;
+  if (ctx.format === "json") {
+    printJson({
+      logged_in: true,
+      device_name: current?.device_name ?? null,
+      session_created_at: current?.created_at ?? null,
+      last_used_at: current?.last_used_at ?? null,
+      local_login_at: localLoginAt
+    });
+    return;
+  }
+  const lines = [
+    "Logged in.",
+    `device:            ${display(current?.device_name)}`,
+    `session created:   ${display(current?.created_at)}`,
+    `last used:         ${display(current?.last_used_at)}`,
+    `local login time:  ${display(localLoginAt)}`
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+}
+function registerWhoamiCommand(program2) {
+  program2.command("whoami").description("Show your current personal login session (contacts the server)").action(async (_flags, command) => {
+    await performWhoami(resolveContext(command));
+  });
+}
+
+// src/commands/auth/logout.ts
+async function performLogout(ctx) {
+  const creds = loadPersonalCredentials();
+  if (!creds) {
+    process.stdout.write("Not logged in.\n");
+    return;
+  }
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  try {
+    await revokeRefreshToken(opts, creds.refresh_token);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    printWarn(`Failed to revoke the session on the server: ${message}. Removing local credentials anyway.`, ctx.color);
+  }
+  deletePersonalCredentials();
+  process.stdout.write("Logged out.\n");
+}
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Sign out of your wport personal account (revokes the refresh token and clears local credentials)").action(async (_flags, command) => {
+    await performLogout(resolveContext(command));
+  });
+}
+
+// src/commands/sessions/list.ts
+function formatDate5(value) {
+  return value ? String(value).slice(0, 10) : "";
+}
+async function runSessionsList(ctx) {
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const { body } = await personalGet(opts, OAUTH_SESSIONS_BASE);
+  const sessions = unwrapDataArray(body);
+  if (ctx.format === "json") {
+    printJson(sessions);
+    return;
+  }
+  printTable(
+    sessions,
+    [
+      { header: "ENC_ID", value: (r) => r.enc_id.slice(0, 14) },
+      { header: "DEVICE", value: (r) => r.device_name ?? "", maxWidth: 24 },
+      { header: "CREATED", value: (r) => formatDate5(r.created_at), maxWidth: 12 },
+      { header: "LAST_USED", value: (r) => formatDate5(r.last_used_at), maxWidth: 12 },
+      { header: "CURRENT", value: (r) => r.is_current ? "*" : "" }
+    ],
+    ctx.color
+  );
+}
+function registerSessionsList(parent) {
+  parent.command("list").description("List your active personal login sessions (devices)").action(async (_flags, command) => {
+    await runSessionsList(resolveContext(command));
+  });
+}
+
+// src/commands/sessions/revoke.ts
+async function runSessionsRevoke(ctx, encId, allOthers) {
+  const hasEncId = encId !== void 0;
+  if (hasEncId === allOthers) {
+    throw new CliError("Provide exactly one of <enc_id> or --all-others", ExitCode.InvalidArgument);
+  }
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  if (allOthers) {
+    const { body } = await personalDelete(opts, `${OAUTH_SESSIONS_BASE}/others`);
+    const result = unwrapDataResponse(body);
+    if (ctx.format === "json") {
+      printJson(result);
+      return;
+    }
+    process.stdout.write(`Revoked ${result.revoked_count} other session(s).
+`);
+    return;
+  }
+  const trimmed = encId.trim();
+  if (!trimmed) throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  await personalDelete(opts, `${OAUTH_SESSIONS_BASE}/${encodeURIComponent(trimmed)}`);
+  if (ctx.format === "json") {
+    printJson({ enc_id: trimmed, revoked: true });
+    return;
+  }
+  process.stdout.write(`Revoked session ${trimmed}.
+`);
+}
+function registerSessionsRevoke(parent) {
+  parent.command("revoke [enc_id]").description("Revoke a session by enc_id, or every other session with --all-others").option("--all-others", "revoke every session except the current one").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    await runSessionsRevoke(ctx, encId, flags.allOthers === true);
+  });
+}
+
+// src/commands/sessions/index.ts
+function registerSessionsCommand(program2) {
+  const sessions = program2.command("sessions").description("List and revoke your personal login sessions (devices)");
+  registerSessionsList(sessions);
+  registerSessionsRevoke(sessions);
+}
+
+// src/lib/resume-schema/definition.ts
+var DEGREE_TYPE_VALUES = ["phd", "master", "bachelor", "associate", "senior_high", "junior_or_below"];
+var EDUCATION_STATUS_VALUES = ["graduated", "dropped", "studying"];
+var JOB_FEATURE_CODE_VALUES = ["dispatch", "executive", "full_time", "internship", "part_time"];
+var WORKING_HOUR_TYPE_VALUES = ["day_shift", "evening_shift", "night_shift", "rotating_shift", "weekend_shift"];
+var AVAILABLE_START_TYPE_VALUES = ["available_after_hired", "available_custom_date"];
+var AVAILABLE_START_PERIOD_VALUES = ["week", "two_weeks", "month", "two_months", "three_months", "anytime"];
+var SALARY_EXPECTATION_TYPE_VALUES = ["negotiable", "company_rules", "custom"];
+var SALARY_UNIT_VALUES = ["hourly", "daily", "monthly", "yearly"];
+var PROFICIENCY_LEVEL_VALUES = ["beginner", "daily_convo", "proficient", "native"];
+var JOB_STATUS_VALUES = ["employed", "military", "student", "unemployed"];
+var VEHICLE_OR_LICENSE_TYPE_VALUES = [
+  "bus",
+  "heavy_motorcycle",
+  "light_motorcycle",
+  "light_car",
+  "pro_bus",
+  "pro_small_car",
+  "pro_trailer",
+  "pro_truck",
+  "scooter",
+  "trailer",
+  "truck"
+];
+var CURRENT_YEAR = (/* @__PURE__ */ new Date()).getFullYear();
+var TOP_LEVEL_FIELDS = {
+  name: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    maxLength: 100,
+    description: "\u5C65\u6B77\u540D\u7A31",
+    example: "\u6211\u7684\u5C65\u6B77\u540D\u7A31"
+  }
+};
+var educationSection = {
+  key: "education",
+  kind: "array",
+  description: "\u5B78\u6B77\uFF0C\u53EF\u591A\u7B46",
+  fields: {
+    school_name: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 80,
+      description: "\u5B78\u6821\u540D\u7A31",
+      example: "National Taiwan University"
+    },
+    degree_code: {
+      type: "enum",
+      required: true,
+      enumValues: DEGREE_TYPE_VALUES,
+      description: "\u5B78\u6B77\u7B49\u7D1A",
+      example: "bachelor"
+    },
+    department: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 80,
+      description: "\u4E3B\u4FEE\u79D1\u7CFB\u540D\u7A31",
+      example: "Computer Science"
+    },
+    minor_department: {
+      type: "string",
+      required: false,
+      minLength: 1,
+      maxLength: 80,
+      description: "\u526F\u4FEE\u79D1\u7CFB\u540D\u7A31",
+      example: "Mathematics"
+    },
+    department_class_code: {
+      type: "string",
+      required: false,
+      description: "\u4E3B\u4FEE\u79D1\u7CFB\u985E\u5225\u4EE3\u78BC",
+      example: "engineering"
+    },
+    minor_department_class_code: {
+      type: "string",
+      required: false,
+      description: "\u526F\u4FEE\u79D1\u7CFB\u985E\u5225\u4EE3\u78BC",
+      example: "industry_machinery"
+    },
+    edu_status_code: {
+      type: "enum",
+      required: true,
+      enumValues: EDUCATION_STATUS_VALUES,
+      description: "\u5C31\u5B78\u72C0\u614B",
+      example: "studying"
+    },
+    start_year: {
+      type: "integer",
+      required: true,
+      min: 1900,
+      max: CURRENT_YEAR,
+      description: "\u5165\u5B78\u5E74\u4EFD",
+      example: 2015
+    },
+    start_month: {
+      type: "integer",
+      required: true,
+      min: 1,
+      max: 12,
+      description: "\u5165\u5B78\u6708\u4EFD",
+      example: 9
+    },
+    end_year: {
+      type: "integer",
+      required: false,
+      min: 1900,
+      max: CURRENT_YEAR,
+      description: "\u7562\u696D\u5E74\u4EFD\uFF08edu_status_code \u70BA graduated/dropped \u6642\u5FC5\u586B\uFF09",
+      example: 2019
+    },
+    end_month: {
+      type: "integer",
+      required: false,
+      min: 1,
+      max: 12,
+      description: "\u7562\u696D\u6708\u4EFD\uFF08edu_status_code \u70BA graduated/dropped \u6642\u5FC5\u586B\uFF09",
+      example: 6
+    },
+    experience: {
+      type: "string",
+      required: false,
+      htmlText: true,
+      maxLength: 2e3,
+      description: "\u5728\u6821\u7D93\u6B77\uFF08\u5BCC\u6587\u672C\uFF09",
+      example: "<p>Served as the president of the student council.</p>"
+    }
+  },
+  crossFieldRules: [
+    {
+      name: "education-graduation-date",
+      message: 'When edu_status_code is "graduated" or "dropped", end_year/end_month are required and the end date must be after start_year/start_month and not later than today.',
+      check(item) {
+        const status = item.edu_status_code;
+        if (status !== "graduated" && status !== "dropped") return true;
+        const { end_year, end_month, start_year, start_month } = item;
+        if (typeof end_year !== "number" || typeof end_month !== "number") return false;
+        if (typeof start_year !== "number" || typeof start_month !== "number") return true;
+        const start = new Date(start_year, start_month - 1);
+        const end = new Date(end_year, end_month - 1);
+        return end > start && end <= /* @__PURE__ */ new Date();
+      }
+    }
+  ]
+};
+var workExperienceSection = {
+  key: "work_experience",
+  kind: "wrapper",
+  description: "\u5DE5\u4F5C\u7D93\u9A57\uFF08\u5305\u88DD\u5C64\u542B\u300C\u7121\u5DE5\u4F5C\u7D93\u9A57\u300D\u65D7\u6A19\uFF09",
+  wrapperFields: {
+    has_no_work_experience: {
+      type: "boolean",
+      required: false,
+      description: "\u662F\u5426\u7121\u5DE5\u4F5C\u7D93\u9A57\uFF08true \u6642 items \u5FC5\u70BA\u7A7A\u9663\u5217\uFF09",
+      example: false
+    }
+  },
+  fields: {
+    job_title: {
+      type: "string",
+      required: true,
+      maxLength: 100,
+      description: "\u8077\u7A31",
+      example: "Software Engineer"
+    },
+    job_type: {
+      type: "enum",
+      required: true,
+      enumValues: JOB_FEATURE_CODE_VALUES,
+      description: "\u8077\u52D9\u985E\u578B",
+      example: "full_time"
+    },
+    company_name: {
+      type: "string",
+      required: true,
+      maxLength: 200,
+      description: "\u516C\u53F8\u540D\u7A31",
+      example: "Tech Corp"
+    },
+    start_year: {
+      type: "integer",
+      required: true,
+      min: 1900,
+      max: CURRENT_YEAR,
+      description: "\u4EFB\u8077\u958B\u59CB\u5E74\u4EFD",
+      example: 2020
+    },
+    start_month: {
+      type: "integer",
+      required: true,
+      min: 1,
+      max: 12,
+      description: "\u4EFB\u8077\u958B\u59CB\u6708\u4EFD",
+      example: 1
+    },
+    end_year: {
+      type: "integer",
+      required: false,
+      min: 1900,
+      max: CURRENT_YEAR,
+      description: "\u4EFB\u8077\u7D50\u675F\u5E74\u4EFD\uFF08is_current \u70BA false \u6642\u5FC5\u586B\uFF09",
+      example: 2022
+    },
+    end_month: {
+      type: "integer",
+      required: false,
+      min: 1,
+      max: 12,
+      description: "\u4EFB\u8077\u7D50\u675F\u6708\u4EFD\uFF08is_current \u70BA false \u6642\u5FC5\u586B\uFF09",
+      example: 12
+    },
+    is_current: {
+      type: "boolean",
+      required: true,
+      description: "\u662F\u5426\u5728\u8077\u4E2D\uFF08\u8B80\u5BEB\u4E0D\u5C0D\u7A31\uFF1A\u805A\u5408\u683C\u5F0F\u53D6 read shape \u70BA boolean\uFF0Corchestrator \u5BEB\u5165\u6642\u8F49 0/1\uFF09",
+      example: false
+    },
+    job_description: {
+      type: "string",
+      required: false,
+      htmlText: true,
+      maxLength: 1e4,
+      description: "\u5DE5\u4F5C\u5167\u5BB9\u63CF\u8FF0\uFF08\u5BCC\u6587\u672C\uFF09",
+      example: "<p>Built and maintained internal developer tools.</p>"
+    }
+  },
+  crossFieldRules: [
+    {
+      name: "work-experience-end-date",
+      message: "When is_current is true, end_year/end_month must not be present. When is_current is false, end_year/end_month are required and the end date must be on/after the start date and not later than today.",
+      check(item) {
+        if (typeof item.is_current !== "boolean") return true;
+        if (item.is_current) {
+          return item.end_year === void 0 && item.end_month === void 0;
+        }
+        const { end_year, end_month, start_year, start_month } = item;
+        if (typeof end_year !== "number" || typeof end_month !== "number") return false;
+        if (typeof start_year !== "number" || typeof start_month !== "number") return true;
+        const start = new Date(start_year, start_month - 1);
+        const end = new Date(end_year, end_month - 1);
+        return end >= start && end <= /* @__PURE__ */ new Date();
+      }
+    },
+    {
+      name: "work-experience-no-experience-items-empty",
+      message: "When has_no_work_experience is true, items must be an empty array.",
+      check(wrapper) {
+        if (wrapper.has_no_work_experience !== true) return true;
+        return Array.isArray(wrapper.items) && wrapper.items.length === 0;
+      }
+    }
+  ]
+};
+var certificateSection = {
+  key: "certificate",
+  kind: "array",
+  description: "\u8B49\u7167\uFF0C\u53EF\u591A\u7B46",
+  fields: {
+    certificate_code: {
+      type: "string",
+      required: true,
+      description: "\u8B49\u7167\u4EE3\u78BC",
+      example: "4001001014"
+    },
+    issue_year: {
+      type: "integer",
+      required: true,
+      min: 1900,
+      max: 2100,
+      description: "\u8D77\u59CB\u5E74\u4EFD\uFF08\u683C\u5F0F\uFF1AYYYY\uFF09",
+      example: 2023
+    },
+    issue_month: {
+      type: "integer",
+      required: true,
+      min: 1,
+      max: 12,
+      description: "\u8D77\u59CB\u6708\u4EFD\uFF08\u683C\u5F0F\uFF1AMM\uFF09",
+      example: 1
+    },
+    expiry_year: {
+      type: "integer",
+      required: false,
+      min: 1900,
+      max: 2100,
+      description: "\u5230\u671F\u5E74\u4EFD\uFF08is_permanent \u70BA false \u6642\u5FC5\u586B\uFF09",
+      example: 2025
+    },
+    expiry_month: {
+      type: "integer",
+      required: false,
+      min: 1,
+      max: 12,
+      description: "\u5230\u671F\u6708\u4EFD\uFF08is_permanent \u70BA false \u6642\u5FC5\u586B\uFF09",
+      example: 1
+    },
+    is_permanent: {
+      type: "boolean",
+      required: true,
+      description: "\u662F\u5426\u6C38\u4E45\u6709\u6548",
+      example: false
+    }
+  },
+  crossFieldRules: [
+    {
+      name: "certificate-expiry-required",
+      message: "When is_permanent is false, expiry_year/expiry_month are required and must not be earlier than issue_year/issue_month.",
+      check(item) {
+        if (item.is_permanent !== false) return true;
+        const { expiry_year, expiry_month, issue_year, issue_month } = item;
+        if (typeof expiry_year !== "number" || typeof expiry_month !== "number") return false;
+        if (typeof issue_year !== "number" || typeof issue_month !== "number") return true;
+        return expiry_year * 12 + expiry_month >= issue_year * 12 + issue_month;
+      }
+    }
+  ]
+};
+var languageSection = {
+  key: "language",
+  kind: "array",
+  description: "\u8A9E\u8A00\u80FD\u529B\uFF0C\u53EF\u591A\u7B46",
+  fields: {
+    code: {
+      type: "string",
+      required: true,
+      description: "\u6280\u80FD\u8A9E\u8A00\u4EE3\u78BC\uFF08\u5C0D\u61C9 skill_languages \u8CC7\u6599\u8868\u4E2D\u7684 code\uFF09",
+      example: "Chinese"
+    },
+    proficiency_level_code: {
+      type: "enum",
+      required: true,
+      enumValues: PROFICIENCY_LEVEL_VALUES,
+      description: "\u719F\u7DF4\u7A0B\u5EA6",
+      example: "proficient"
+    }
+  }
+};
+var professionalSkillsSection = {
+  key: "professional_skills",
+  kind: "object",
+  description: "\u5C08\u696D\u6280\u80FD",
+  fields: {
+    tech_tool_codes: {
+      type: "string[]",
+      required: true,
+      minItems: 1,
+      maxItems: 10,
+      description: "\u5DE5\u5177\u4EE3\u78BC\u9663\u5217\uFF08\u6700\u591A 10 \u500B\uFF09",
+      example: ["12001001045", "12001001044"]
+    },
+    other_tool_description: {
+      type: "string",
+      required: false,
+      htmlText: true,
+      maxLength: 2e3,
+      description: "\u5176\u4ED6\u64C5\u9577\u5DE5\u5177\u63CF\u8FF0\uFF08\u5BCC\u6587\u672C\uFF0C\u5BE6\u969B\u6587\u5B57\u4E0A\u9650 2000 \u5B57\uFF09",
+      example: "\u719F\u6089 Photoshop \u548C Illustrator"
+    },
+    job_skill_codes: {
+      type: "string[]",
+      required: true,
+      minItems: 1,
+      maxItems: 10,
+      description: "\u6280\u80FD\u4EE3\u78BC\u9663\u5217\uFF08\u6700\u591A 10 \u500B\uFF09",
+      example: ["5001001006", "5001001007"]
+    },
+    other_job_skill_description: {
+      type: "string",
+      required: false,
+      htmlText: true,
+      maxLength: 2e3,
+      description: "\u5176\u4ED6\u5DE5\u4F5C\u6280\u80FD\u63CF\u8FF0\uFF08\u5BCC\u6587\u672C\uFF0C\u5BE6\u969B\u6587\u5B57\u4E0A\u9650 2000 \u5B57\uFF09",
+      example: "\u719F\u6089 Scrum \u548C\u654F\u6377\u958B\u767C\u6D41\u7A0B"
+    }
+  }
+};
+var autobiographySection = {
+  key: "autobiography",
+  kind: "scalar",
+  description: "\u81EA\u50B3\uFF08\u7D14\u5B57\u4E32\u7BC0\uFF09",
+  valueDef: {
+    type: "string",
+    required: true,
+    htmlText: true,
+    maxLength: 3e3,
+    description: "\u81EA\u50B3\u5167\u5BB9\uFF08\u5BCC\u6587\u672C\u683C\u5F0F\uFF09\uFF0C\u5BE6\u969B\u6587\u5B57\u9577\u5EA6\u4E0D\u8D85\u904E 3000 \u5B57",
+    example: "<p>This is my <strong>autobiography</strong>.</p>"
+  }
+};
+var jobConditionSection = {
+  key: "job_condition",
+  kind: "object",
+  description: "\u5E0C\u671B\u5DE5\u4F5C\u689D\u4EF6",
+  fields: {
+    feature_codes: {
+      type: "enum[]",
+      required: true,
+      enumValues: JOB_FEATURE_CODE_VALUES,
+      description: "\u5E0C\u671B\u6027\u8CEA\u4EE3\u78BC\uFF08\u591A\u9078\uFF09",
+      example: ["full_time", "part_time"]
+    },
+    working_hour_type_codes: {
+      type: "enum[]",
+      required: true,
+      enumValues: WORKING_HOUR_TYPE_VALUES,
+      description: "\u4E0A\u73ED\u6642\u6BB5\u4EE3\u78BC\uFF08\u591A\u9078\uFF09",
+      example: ["day_shift", "evening_shift"]
+    },
+    available_start_type_code: {
+      type: "enum",
+      required: true,
+      enumValues: AVAILABLE_START_TYPE_VALUES,
+      description: "\u53EF\u4E0A\u73ED\u6642\u9593\u985E\u578B\u4EE3\u78BC",
+      example: "available_after_hired"
+    },
+    available_start_date: {
+      type: "date",
+      required: false,
+      description: "\u81EA\u8A02\u53EF\u4E0A\u73ED\u65E5\u671F\uFF08available_start_type_code \u70BA available_custom_date \u6642\u5FC5\u586B\uFF09",
+      example: "2025-05-01"
+    },
+    available_start_period_code: {
+      type: "enum",
+      required: false,
+      enumValues: AVAILABLE_START_PERIOD_VALUES,
+      description: "\u9304\u53D6\u5F8C\u671F\u9593\u4EE3\u78BC\uFF08available_start_type_code \u70BA available_after_hired \u6642\u5FC5\u586B\uFF09",
+      example: "week"
+    },
+    salary_expectation_type_code: {
+      type: "enum",
+      required: true,
+      enumValues: SALARY_EXPECTATION_TYPE_VALUES,
+      description: "\u5E0C\u671B\u5F85\u9047\u985E\u578B\u4EE3\u78BC",
+      example: "negotiable"
+    },
+    salary_unit_code: {
+      type: "enum",
+      required: false,
+      enumValues: SALARY_UNIT_VALUES,
+      description: "\u85AA\u8CC7\u55AE\u4F4D\u4EE3\u78BC\uFF08salary_expectation_type_code \u70BA custom \u6642\u5FC5\u586B\uFF09",
+      example: "monthly"
+    },
+    salary_amount: {
+      type: "number",
+      required: false,
+      min: 0,
+      description: "\u81EA\u8A02\u85AA\u8CC7\u91D1\u984D\uFF08salary_expectation_type_code \u70BA custom \u6642\u5FC5\u586B\uFF09",
+      example: 5e4
+    },
+    expected_salary_currency_code: {
+      type: "string",
+      required: false,
+      minLength: 3,
+      maxLength: 3,
+      description: "\u671F\u671B\u85AA\u8CC7\u5E63\u5225\u4EE3\u78BC\uFF08ISO 4217\uFF0Csalary_expectation_type_code \u70BA custom \u6642\u5FC5\u586B\uFF09",
+      example: "TWD"
+    },
+    area_codes: {
+      type: "string[]",
+      required: false,
+      description: "\u5E0C\u671B\u5730\u9EDE\u4EE3\u78BC\uFF08\u591A\u9078\uFF09",
+      example: ["6001005009", "6001006008"]
+    },
+    job_classification_codes: {
+      type: "string[]",
+      required: false,
+      description: "\u5E0C\u671B\u8077\u985E\u4EE3\u78BC\uFF08\u591A\u9078\uFF09",
+      example: ["2002002006", "2003002007"]
+    }
+  },
+  crossFieldRules: [
+    {
+      name: "job-condition-available-start",
+      message: 'When available_start_type_code is "available_custom_date", available_start_date is required. When it is "available_after_hired", available_start_period_code is required.',
+      check(item) {
+        const code = item.available_start_type_code;
+        if (code === "available_custom_date") {
+          const v = item.available_start_date;
+          return v !== void 0 && v !== null && v !== "";
+        }
+        if (code === "available_after_hired") {
+          const v = item.available_start_period_code;
+          return v !== void 0 && v !== null && v !== "";
+        }
+        return true;
+      }
+    },
+    {
+      name: "job-condition-salary-expectation",
+      message: 'When salary_expectation_type_code is "custom", salary_unit_code, salary_amount, and expected_salary_currency_code are all required.',
+      check(item) {
+        if (item.salary_expectation_type_code !== "custom") return true;
+        const hasUnit = item.salary_unit_code !== void 0 && item.salary_unit_code !== null && item.salary_unit_code !== "";
+        const hasAmount = typeof item.salary_amount === "number";
+        const hasCurrency = typeof item.expected_salary_currency_code === "string" && item.expected_salary_currency_code.length > 0;
+        return hasUnit && hasAmount && hasCurrency;
+      }
+    }
+  ]
+};
+var portfolioLinksSection = {
+  key: "portfolio_links",
+  kind: "array",
+  maxItems: 5,
+  description: "\u4F5C\u54C1\u96C6\u9023\u7D50\uFF0C\u6700\u591A 5 \u7B46",
+  fields: {
+    link_title: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 50,
+      description: "\u4F5C\u54C1\u96C6\u6A19\u984C",
+      example: "My Portfolio"
+    },
+    link_url: {
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: 2083,
+      description: "\u4F5C\u54C1\u96C6\u9023\u7D50\uFF08URL\uFF09",
+      example: "https://myportfolio.com"
+    }
+  }
+};
+var backgroundSection = {
+  key: "background",
+  kind: "object",
+  description: "\u80CC\u666F\u8CC7\u8A0A\uFF08\u99D5\u7167\uFF0F\u8ECA\u8F1B\uFF0F\u5175\u5F79\u72C0\u614B\uFF09",
+  fields: {
+    // identity_types（身分種類）刻意不列：屬會員個資唯讀例外（pm_27 欄位），寫聚合不收，
+    // validate 對此鍵給 read-only 專屬訊息而非泛用 unknown-field（見 design doc §4.2）。
+    driving_license_types: {
+      type: "enum[]",
+      required: false,
+      enumValues: VEHICLE_OR_LICENSE_TYPE_VALUES,
+      description: "\u99D5\u99DB\u57F7\u7167\u985E\u578B\u5217\u8868",
+      example: ["scooter", "light_motorcycle"]
+    },
+    vehicle_types: {
+      type: "enum[]",
+      required: false,
+      enumValues: VEHICLE_OR_LICENSE_TYPE_VALUES,
+      description: "\u8ECA\u8F1B\u985E\u578B\u5217\u8868",
+      example: ["scooter"]
+    },
+    job_status: {
+      type: "enum",
+      required: false,
+      enumValues: JOB_STATUS_VALUES,
+      description: "\u5DE5\u4F5C\u72C0\u614B",
+      example: "employed"
+    }
+  }
+};
+var SECTIONS = [
+  educationSection,
+  workExperienceSection,
+  certificateSection,
+  languageSection,
+  professionalSkillsSection,
+  autobiographySection,
+  jobConditionSection,
+  portfolioLinksSection,
+  backgroundSection
+];
+function getSection(key) {
+  return SECTIONS.find((s) => s.key === key);
+}
+
+// src/lib/resume-schema/to-json-schema.ts
+var JSON_SCHEMA_DRAFT = "http://json-schema.org/draft-07/schema#";
+function fieldDefToJsonSchema(field) {
+  const out = {};
+  switch (field.type) {
+    case "string":
+      out.type = "string";
+      if (field.minLength !== void 0) out.minLength = field.minLength;
+      if (field.maxLength !== void 0) out.maxLength = field.maxLength;
+      break;
+    case "number":
+      out.type = "number";
+      if (field.min !== void 0) out.minimum = field.min;
+      if (field.max !== void 0) out.maximum = field.max;
+      break;
+    case "integer":
+      out.type = "integer";
+      if (field.min !== void 0) out.minimum = field.min;
+      if (field.max !== void 0) out.maximum = field.max;
+      break;
+    case "boolean":
+      out.type = "boolean";
+      break;
+    case "enum":
+      out.type = "string";
+      out.enum = field.enumValues ? [...field.enumValues] : [];
+      break;
+    case "string[]":
+      out.type = "array";
+      out.items = { type: "string" };
+      if (field.minItems !== void 0) out.minItems = field.minItems;
+      if (field.maxItems !== void 0) out.maxItems = field.maxItems;
+      break;
+    case "enum[]":
+      out.type = "array";
+      out.items = { type: "string", enum: field.enumValues ? [...field.enumValues] : [] };
+      if (field.minItems !== void 0) out.minItems = field.minItems;
+      if (field.maxItems !== void 0) out.maxItems = field.maxItems;
+      break;
+    case "date":
+      out.type = "string";
+      out.format = "date";
+      break;
+  }
+  out.description = field.htmlText ? `${field.description}(\u5B57\u6578\u4E0A\u9650\u8A08\u7B97\u65B9\u5F0F:\u5148\u525D\u9664 HTML tag,\u4EE5\u7D14\u6587\u5B57\u9577\u5EA6\u8A08\u7B97)` : field.description;
+  if (field.example !== void 0) out.example = field.example;
+  return out;
+}
+function fieldsToPropertiesAndRequired(fields) {
+  const properties = {};
+  const required = [];
+  for (const [key, field] of Object.entries(fields)) {
+    properties[key] = fieldDefToJsonSchema(field);
+    if (field.required) required.push(key);
+  }
+  return { properties, required };
+}
+function buildSectionSchema(section) {
+  if (section.kind === "scalar") {
+    return fieldDefToJsonSchema(section.valueDef);
+  }
+  if (section.kind === "object") {
+    const { properties, required } = fieldsToPropertiesAndRequired(section.fields);
+    return {
+      type: "object",
+      description: section.description,
+      additionalProperties: false,
+      required,
+      properties
+    };
+  }
+  if (section.kind === "array") {
+    const { properties, required } = fieldsToPropertiesAndRequired(section.fields);
+    const schema = {
+      type: "array",
+      description: section.description,
+      items: { type: "object", additionalProperties: false, required, properties }
+    };
+    if (section.maxItems !== void 0) schema.maxItems = section.maxItems;
+    return schema;
+  }
+  const wrapperParts = fieldsToPropertiesAndRequired(section.wrapperFields ?? {});
+  const itemParts = fieldsToPropertiesAndRequired(section.fields);
+  return {
+    type: "object",
+    description: section.description,
+    additionalProperties: false,
+    required: [...wrapperParts.required, "items"],
+    properties: {
+      ...wrapperParts.properties,
+      items: {
+        type: "array",
+        items: { type: "object", additionalProperties: false, required: itemParts.required, properties: itemParts.properties }
+      }
+    }
+  };
+}
+function buildAggregateJsonSchema(sectionKey) {
+  if (sectionKey !== void 0) {
+    const section = getSection(sectionKey);
+    if (!section) {
+      const allowed = SECTIONS.map((s) => s.key).join(", ");
+      throw new CliError(`Unknown section "${sectionKey}". Allowed: ${allowed}`, ExitCode.InvalidArgument);
+    }
+    return buildSectionSchema(section);
+  }
+  const properties = {
+    name: fieldDefToJsonSchema(TOP_LEVEL_FIELDS.name)
+  };
+  for (const section of SECTIONS) {
+    properties[section.key] = buildSectionSchema(section);
+  }
+  return {
+    $schema: JSON_SCHEMA_DRAFT,
+    title: "wport resume aggregate",
+    description: "wport \u5C65\u6B77\u805A\u5408\u683C\u5F0F(\u4F9B personal resumes create/update/validate \u4F7F\u7528)\u3002view \u8F38\u51FA\u53E6\u542B\u552F\u8B80\u7684 photo_url(\u6703\u54E1\u500B\u8CC7),\u4E0D\u5728\u6B64\u5BEB\u5165\u805A\u5408 schema \u5167,\u5982\u9700\u66F4\u65B0\u8ACB\u8D70 profile \u76F8\u95DC\u6D41\u7A0B\u3002",
+    type: "object",
+    additionalProperties: false,
+    required: ["name"],
+    properties
+  };
+}
+
+// src/commands/personal/resumes/schema.ts
+function registerPersonalResumesSchema(parent) {
+  parent.command("schema").description("Print the resume aggregate JSON Schema (offline, no login required)").option("--section <name>", "print only the given section (e.g. education, work_experience)").action((opts) => {
+    printJson(buildAggregateJsonSchema(opts.section));
+  });
+}
+
+// src/lib/resume-schema/validate.ts
+var TOP_LEVEL_READ_ONLY_KEYS = /* @__PURE__ */ new Set(["photo_url"]);
+var BACKGROUND_READ_ONLY_KEYS = /* @__PURE__ */ new Set(["identity_types"]);
+var NO_READ_ONLY_KEYS = /* @__PURE__ */ new Set();
+function itemAllowedKeys(fields) {
+  return /* @__PURE__ */ new Set([...Object.keys(fields), "enc_id"]);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  return typeof value;
+}
+function unknownFieldMessage(key) {
+  return `Unknown field "${key}" \u2014 not part of the resume schema`;
+}
+function readOnlyFieldMessage(key) {
+  return `Field "${key}" is read-only (member profile data) \u2014 not part of the resume write aggregate`;
+}
+function stripHtml2(s) {
+  return s.replace(/<[^>]*>/g, "");
+}
+function isValidDateString(s) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(s)) return false;
+  const [y, m, d] = s.split("-").map(Number);
+  const date = new Date(Date.UTC(y, m - 1, d));
+  return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+function checkUnknownKeys(obj, allowedKeys, readOnlyKeys, pathFor, issues) {
+  for (const key of Object.keys(obj)) {
+    if (allowedKeys.has(key)) continue;
+    if (readOnlyKeys.has(key)) {
+      issues.push({ path: pathFor(key), message: readOnlyFieldMessage(key) });
+      continue;
+    }
+    issues.push({ path: pathFor(key), message: unknownFieldMessage(key) });
+  }
+}
+function checkFieldValue(field, value, path, issues) {
+  switch (field.type) {
+    case "string": {
+      if (typeof value !== "string") {
+        issues.push({ path, message: `Expected a string (got ${describeType(value)})` });
+        return;
+      }
+      const text = field.htmlText ? stripHtml2(value) : value;
+      if (field.minLength !== void 0 && text.length < field.minLength) {
+        issues.push({ path, message: `Must be at least ${field.minLength} characters (got ${text.length})` });
+      }
+      if (field.maxLength !== void 0 && text.length > field.maxLength) {
+        issues.push({ path, message: `Must be at most ${field.maxLength} characters (got ${text.length})` });
+      }
+      return;
+    }
+    case "number": {
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        issues.push({ path, message: `Expected a number (got ${describeType(value)})` });
+        return;
+      }
+      checkRange(field, value, path, issues);
+      return;
+    }
+    case "integer": {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        issues.push({ path, message: `Expected an integer (got ${describeType(value)})` });
+        return;
+      }
+      checkRange(field, value, path, issues);
+      return;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") issues.push({ path, message: `Expected a boolean (got ${describeType(value)})` });
+      return;
+    }
+    case "enum": {
+      const allowed = field.enumValues ?? [];
+      if (typeof value !== "string" || !allowed.includes(value)) {
+        issues.push({ path, message: `Invalid value ${JSON.stringify(value)} \u2014 allowed: ${allowed.join(", ")}` });
+      }
+      return;
+    }
+    case "string[]": {
+      if (!Array.isArray(value)) {
+        issues.push({ path, message: `Expected an array (got ${describeType(value)})` });
+        return;
+      }
+      value.forEach((v, i) => {
+        if (typeof v !== "string") issues.push({ path: `${path}[${i}]`, message: `Expected a string (got ${describeType(v)})` });
+      });
+      checkItemsCount(field, value, path, issues);
+      return;
+    }
+    case "enum[]": {
+      const allowed = field.enumValues ?? [];
+      if (!Array.isArray(value)) {
+        issues.push({ path, message: `Expected an array (got ${describeType(value)})` });
+        return;
+      }
+      value.forEach((v, i) => {
+        if (typeof v !== "string" || !allowed.includes(v)) {
+          issues.push({ path: `${path}[${i}]`, message: `Invalid value ${JSON.stringify(v)} \u2014 allowed: ${allowed.join(", ")}` });
+        }
+      });
+      checkItemsCount(field, value, path, issues);
+      return;
+    }
+    case "date": {
+      if (typeof value !== "string" || !isValidDateString(value)) {
+        issues.push({ path, message: `Expected a date string in YYYY-MM-DD format (got ${JSON.stringify(value)})` });
+      }
+      return;
+    }
+  }
+}
+function checkRange(field, value, path, issues) {
+  if (field.min !== void 0 && value < field.min) issues.push({ path, message: `Must be >= ${field.min} (got ${value})` });
+  if (field.max !== void 0 && value > field.max) issues.push({ path, message: `Must be <= ${field.max} (got ${value})` });
+}
+function checkItemsCount(field, value, path, issues) {
+  if (field.minItems !== void 0 && value.length < field.minItems) {
+    issues.push({ path, message: `Must have at least ${field.minItems} item(s) (got ${value.length})` });
+  }
+  if (field.maxItems !== void 0 && value.length > field.maxItems) {
+    issues.push({ path, message: `Must have at most ${field.maxItems} item(s) (got ${value.length})` });
+  }
+}
+function checkFields(obj, fields, pathFor, issues) {
+  for (const [key, field] of Object.entries(fields)) {
+    const value = obj[key];
+    const path = pathFor(key);
+    if (value === void 0) {
+      if (field.required) issues.push({ path, message: `Missing required field "${key}"` });
+      continue;
+    }
+    checkFieldValue(field, value, path, issues);
+  }
+}
+function checkCrossFieldRules(rules, item, path, issues) {
+  for (const rule of rules ?? []) {
+    if (!rule.check(item)) issues.push({ path, message: rule.message });
+  }
+}
+function validateArraySection(section, value, issues) {
+  const path = section.key;
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: `Expected an array (got ${describeType(value)})` });
+    return;
+  }
+  if (section.maxItems !== void 0 && value.length > section.maxItems) {
+    issues.push({ path, message: `Must have at most ${section.maxItems} item(s) (got ${value.length})` });
+  }
+  value.forEach((item, i) => {
+    const itemPath = `${path}[${i}]`;
+    if (!isPlainObject(item)) {
+      issues.push({ path: itemPath, message: `Expected an object (got ${describeType(item)})` });
+      return;
+    }
+    checkUnknownKeys(item, itemAllowedKeys(section.fields), NO_READ_ONLY_KEYS, (k) => `${itemPath}.${k}`, issues);
+    checkFields(item, section.fields, (k) => `${itemPath}.${k}`, issues);
+    checkCrossFieldRules(section.crossFieldRules, item, itemPath, issues);
+  });
+}
+function validateObjectSection(section, value, issues) {
+  const path = section.key;
+  if (!isPlainObject(value)) {
+    issues.push({ path, message: `Expected an object (got ${describeType(value)})` });
+    return;
+  }
+  const readOnly = section.key === "background" ? BACKGROUND_READ_ONLY_KEYS : NO_READ_ONLY_KEYS;
+  checkUnknownKeys(value, new Set(Object.keys(section.fields)), readOnly, (k) => `${path}.${k}`, issues);
+  checkFields(value, section.fields, (k) => `${path}.${k}`, issues);
+  checkCrossFieldRules(section.crossFieldRules, value, path, issues);
+}
+function validateScalarSection(section, value, issues) {
+  checkFieldValue(section.valueDef, value, section.key, issues);
+}
+function validateWrapperSection(section, value, issues) {
+  const path = section.key;
+  if (!isPlainObject(value)) {
+    issues.push({ path, message: `Expected an object (got ${describeType(value)})` });
+    return;
+  }
+  const wrapperFields = section.wrapperFields ?? {};
+  const allowedTopKeys = /* @__PURE__ */ new Set([...Object.keys(wrapperFields), "items"]);
+  checkUnknownKeys(value, allowedTopKeys, NO_READ_ONLY_KEYS, (k) => `${path}.${k}`, issues);
+  checkFields(value, wrapperFields, (k) => `${path}.${k}`, issues);
+  const items = value.items;
+  const itemsPath = `${path}.items`;
+  if (items === void 0) {
+    issues.push({ path: itemsPath, message: 'Missing required field "items"' });
+  } else if (!Array.isArray(items)) {
+    issues.push({ path: itemsPath, message: `Expected an array (got ${describeType(items)})` });
+  } else {
+    items.forEach((item, i) => {
+      const itemPath = `${itemsPath}[${i}]`;
+      if (!isPlainObject(item)) {
+        issues.push({ path: itemPath, message: `Expected an object (got ${describeType(item)})` });
+        return;
+      }
+      checkUnknownKeys(item, itemAllowedKeys(section.fields), NO_READ_ONLY_KEYS, (k) => `${itemPath}.${k}`, issues);
+      checkFields(item, section.fields, (k) => `${itemPath}.${k}`, issues);
+      checkCrossFieldRules(section.crossFieldRules, item, itemPath, issues);
+    });
+  }
+  checkCrossFieldRules(section.crossFieldRules, value, path, issues);
+}
+function validateAggregate(input) {
+  if (!isPlainObject(input)) {
+    return [{ path: "(root)", message: `Input must be a JSON object at the top level (got ${describeType(input)})` }];
+  }
+  const issues = [];
+  const allowedTopKeys = /* @__PURE__ */ new Set(["name", ...SECTIONS.map((s) => s.key)]);
+  checkUnknownKeys(input, allowedTopKeys, TOP_LEVEL_READ_ONLY_KEYS, (k) => k, issues);
+  checkFields(input, TOP_LEVEL_FIELDS, (k) => k, issues);
+  for (const section of SECTIONS) {
+    const value = input[section.key];
+    if (value === void 0) continue;
+    switch (section.kind) {
+      case "array":
+        validateArraySection(section, value, issues);
+        break;
+      case "object":
+        validateObjectSection(section, value, issues);
+        break;
+      case "scalar":
+        validateScalarSection(section, value, issues);
+        break;
+      case "wrapper":
+        validateWrapperSection(section, value, issues);
+        break;
+    }
+  }
+  return issues;
+}
+
+// src/commands/personal/resumes/validate.ts
+function runResumesValidate(ctx, filePath) {
+  const input = readJsonInput(filePath, { timeoutMs: ctx.timeoutMs });
+  const issues = validateAggregate(input);
+  if (issues.length === 0) {
+    if (ctx.format === "json") {
+      printJson({ valid: true });
+    } else {
+      process.stdout.write("Valid.\n");
+    }
+    return;
+  }
+  if (ctx.format === "json") {
+    printJson({ valid: false, issues });
+  } else {
+    for (const issue of issues) {
+      process.stderr.write(`${sanitizeForTerminal(issue.path)}: ${sanitizeForTerminal(issue.message)}
+`);
+    }
+  }
+  throw new CliError(`${issues.length} validation issue(s) found`, ExitCode.InvalidArgument);
+}
+function registerPersonalResumesValidate(parent) {
+  parent.command("validate").description("Validate a resume aggregate JSON file locally (offline, no login required)").requiredOption("--file <path>", 'path to a JSON resume aggregate, or "-" for stdin').action((flags, command) => {
+    const ctx = resolveContext(command);
+    runResumesValidate(ctx, flags.file);
+  });
+}
+
+// src/commands/personal/resumes/template.ts
+var import_node_fs8 = require("fs");
+
+// src/lib/resume-schema/template.ts
+function buildFieldsExample(fields) {
+  const out = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.example !== void 0) out[key] = field.example;
+  }
+  return out;
+}
+function buildSectionTemplate(section) {
+  switch (section.kind) {
+    case "scalar":
+      return section.valueDef.example;
+    case "object":
+      return buildFieldsExample(section.fields);
+    case "array":
+      return [buildFieldsExample(section.fields)];
+    case "wrapper":
+      return {
+        ...buildFieldsExample(section.wrapperFields ?? {}),
+        items: [buildFieldsExample(section.fields)]
+      };
+  }
+}
+function buildTemplate() {
+  const template = {
+    name: TOP_LEVEL_FIELDS.name.example
+  };
+  for (const section of SECTIONS) {
+    template[section.key] = buildSectionTemplate(section);
+  }
+  return template;
+}
+
+// src/commands/personal/resumes/template.ts
+function runResumesTemplate(outPath) {
+  const template = buildTemplate();
+  if (outPath === void 0) {
+    printJson(template);
+    return;
+  }
+  if ((0, import_node_fs8.existsSync)(outPath)) {
+    throw new InvalidArgumentError(`File already exists: ${outPath} (refusing to overwrite \u2014 remove it or choose a different --out path)`);
+  }
+  try {
+    (0, import_node_fs8.writeFileSync)(outPath, `${JSON.stringify(template, null, 2)}
+`, "utf8");
+  } catch (err) {
+    throw new InvalidArgumentError(`Failed to write template to ${outPath}: ${err.message}`);
+  }
+  process.stdout.write(`Wrote template to ${outPath}
+`);
+}
+function registerPersonalResumesTemplate(parent) {
+  parent.command("template").description("Print (or write) a resume aggregate skeleton with example values for every field (offline, no login required)").option("--out <file>", "write the template to this file instead of stdout (fails if the file already exists)").action((flags) => {
+    runResumesTemplate(flags.out);
+  });
+}
+
+// src/commands/personal/resumes/list.ts
+var MINIMAL_LIST_FIELDS4 = ["enc_id", "name", "updated_at", "is_complete", "is_published"];
+function formatDate6(value) {
+  return value ? String(value).slice(0, 10) : "";
+}
+function formatQuotaLine(quota) {
+  const status = quota.can_create ? "can create" : `cannot create${quota.reason_code ? ` (${quota.reason_code})` : ""}`;
+  return `${quota.used}/${quota.max_resumes} used, ${status}.`;
+}
+async function fetchResumeList(opts) {
+  const { body } = await personalGet(opts, PERSONAL_RESUMES_BASE);
+  return unwrapDataResponse(body);
+}
+async function runResumesList(ctx, flags) {
+  if (flags.fields && flags.minimal) {
+    throw new CliError("Use either --fields or --minimal, not both", ExitCode.InvalidArgument);
+  }
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const data = await fetchResumeList(opts);
+  const projection = flags.minimal ? MINIMAL_LIST_FIELDS4 : flags.fields ? parseFieldsList(flags.fields) : void 0;
+  if (projection || ctx.format === "json") {
+    printJson(projection ? { ...data, resumes: data.resumes.map((r) => pickPaths(r, projection)) } : data);
+    return;
+  }
+  printTable(
+    data.resumes,
+    [
+      { header: "ENC_ID", value: (r) => r.enc_id.slice(0, 14) },
+      { header: "NAME", value: (r) => r.name, maxWidth: 24 },
+      { header: "UPDATED", value: (r) => formatDate6(r.updated_at), maxWidth: 12 },
+      { header: "COMPLETE", value: (r) => r.is_complete ? "yes" : "no" },
+      { header: "PUBLISHED", value: (r) => r.is_published ? "yes" : "no" }
+    ],
+    ctx.color
+  );
+  process.stdout.write(dim(formatQuotaLine(data.quota), ctx.color) + "\n");
+}
+function registerPersonalResumesList(parent) {
+  parent.command("list").description("List your personal resumes").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths, applied to each resume)").option("--minimal", `output only ${MINIMAL_LIST_FIELDS4.join(",")} as JSON`).action(async (flags, command) => {
+    await runResumesList(resolveContext(command), flags);
+  });
+}
+
+// src/commands/personal/resumes/view.ts
+async function fetchResumeAggregate(opts, encId) {
+  const trimmed = encId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  }
+  const { body } = await personalGet(opts, `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(trimmed)}`);
+  return unwrapDataResponse(body);
+}
+function summarizeSections(resume) {
+  const rows = [{ section: "name", summary: resume.name }];
+  for (const def of SECTIONS) {
+    rows.push({ section: def.key, summary: summarizeSection(def, resume) });
+  }
+  return rows;
+}
+function summarizeSection(def, resume) {
+  const value = resume[def.key];
+  if (def.kind === "array") {
+    return `${Array.isArray(value) ? value.length : 0} item(s)`;
+  }
+  if (def.kind === "wrapper") {
+    const wrapper = value;
+    if (wrapper?.has_no_work_experience) return "no work experience";
+    return `${Array.isArray(wrapper?.items) ? wrapper.items.length : 0} item(s)`;
+  }
+  if (def.kind === "scalar") {
+    return typeof value === "string" && value.length > 0 ? "present" : "absent";
+  }
+  return value && typeof value === "object" && Object.keys(value).length > 0 ? "present" : "absent";
+}
+async function runResumesView(ctx, encId, flags) {
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const resume = await fetchResumeAggregate(opts, encId);
+  if (flags.fields) {
+    printJson(pickPaths(resume, parseFieldsList(flags.fields)));
+    return;
+  }
+  if (ctx.format === "json") {
+    printJson(resume);
+    return;
+  }
+  printTable(
+    summarizeSections(resume),
+    [
+      { header: "SECTION", value: (r) => r.section, maxWidth: 20 },
+      { header: "SUMMARY", value: (r) => r.summary, maxWidth: 40 }
+    ],
+    ctx.color
+  );
+}
+function registerPersonalResumesView(parent) {
+  parent.command("view <enc_id>").description("View one resume aggregate (all sections)").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").action(async (encId, flags, command) => {
+    await runResumesView(resolveContext(command), encId, flags);
+  });
+}
+
+// src/commands/personal/resumes/export.ts
+var import_node_fs9 = require("fs");
+var import_node_path4 = require("path");
+function safeResumeFilename(encId) {
+  if (encId.includes("/") || encId.includes("\\") || encId === "." || encId === "..") {
+    throw new CliError(
+      `Unexpected enc_id from server: "${encId}" (contains path separators; refusing to write outside --out)`,
+      ExitCode.ServerOrNetworkError
+    );
+  }
+  return `resume-${encId}.json`;
+}
+async function runResumesExport(ctx, outDir) {
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const { resumes } = await fetchResumeList(opts);
+  (0, import_node_fs9.mkdirSync)(outDir, { recursive: true });
+  for (const item of resumes) {
+    const filePath = (0, import_node_path4.join)(outDir, safeResumeFilename(item.enc_id));
+    const aggregate = await fetchResumeAggregate(opts, item.enc_id);
+    (0, import_node_fs9.writeFileSync)(filePath, `${JSON.stringify(aggregate, null, 2)}
+`, "utf8");
+  }
+  process.stdout.write(`Exported ${resumes.length} resume(s) to ${outDir}.
+`);
+}
+function registerPersonalResumesExport(parent) {
+  parent.command("export").description("Export all your resumes as one JSON file per resume").option("--out <dir>", "destination directory (default: current directory)").action(async (flags, command) => {
+    await runResumesExport(resolveContext(command), flags.out ?? process.cwd());
+  });
+}
+
+// src/lib/resume-orchestrator.ts
+var import_node_crypto11 = require("crypto");
+function freshIdempotencyKey() {
+  return { idempotencyKey: (0, import_node_crypto11.randomUUID)() };
+}
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function extractErrorCode(body) {
+  if (body && typeof body === "object" && typeof body.error_code === "string") {
+    return body.error_code;
+  }
+  return null;
+}
+async function createShell(opts) {
+  try {
+    const { body } = await personalPost(opts, PERSONAL_RESUMES_BASE, {}, freshIdempotencyKey());
+    return unwrapDataResponse(body).enc_id;
+  } catch (err) {
+    if (err instanceof ServerClientHttpError) {
+      const code = extractErrorCode(err.body);
+      if (code === "profile_incomplete") {
+        throw new CliError(
+          "Cannot create resume: your member profile is incomplete. Complete the required profile fields first, then retry (server: profile_incomplete).",
+          ExitCode.ServerClientError
+        );
+      }
+      if (code === "resume_limit_reached") {
+        throw new CliError(
+          "Cannot create resume: you have reached your resume limit. Delete an existing resume first, then retry (server: resume_limit_reached).",
+          ExitCode.ServerClientError
+        );
+      }
+    }
+    throw err;
+  }
+}
+async function renameResume(opts, encId, name) {
+  await personalPut(opts, `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(encId)}/name`, { name }, freshIdempotencyKey());
+}
+function toWorkExperienceWriteItem(item) {
+  const { is_current, ...rest } = item;
+  return { ...rest, is_current: is_current ? 1 : 0 };
+}
+function splitItemEncId(item) {
+  const { enc_id, ...rest } = item;
+  const valid = typeof enc_id === "string" && enc_id.trim() ? enc_id.trim() : null;
+  return [valid, rest];
+}
+async function writeSection(opts, encId, key, value, mode) {
+  const plan = SECTION_WRITE_PLAN[key];
+  const base = `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(encId)}`;
+  switch (plan.kind) {
+    case "per-item-post": {
+      for (const item of value) {
+        const [itemEncId, body] = splitItemEncId(item);
+        if (mode === "update" && itemEncId) {
+          await personalPut(opts, `${base}${plan.path}/${encodeURIComponent(itemEncId)}`, body, freshIdempotencyKey());
+        } else {
+          await personalPost(opts, `${base}${plan.path}`, body, freshIdempotencyKey());
+        }
+      }
+      return;
+    }
+    case "work-experience": {
+      const wrapper = value;
+      if (wrapper.has_no_work_experience) {
+        await personalPost(opts, `${base}${plan.path}/no-work-experience`, {}, freshIdempotencyKey());
+        return;
+      }
+      for (const item of wrapper.items) {
+        const [itemEncId, rest] = splitItemEncId(item);
+        const body = toWorkExperienceWriteItem(rest);
+        if (mode === "update" && itemEncId) {
+          await personalPut(opts, `${base}${plan.path}`, { encId: itemEncId, ...body }, freshIdempotencyKey());
+        } else {
+          await personalPost(opts, `${base}${plan.path}`, body, freshIdempotencyKey());
+        }
+      }
+      return;
+    }
+    case "single-post": {
+      const body = key === "autobiography" ? { autobiography: value } : value;
+      const write = mode === "create" ? personalPost : personalPut;
+      await write(opts, `${base}${plan.path}`, body, freshIdempotencyKey());
+      return;
+    }
+    case "bulk-put": {
+      const items = value;
+      await personalPut(
+        opts,
+        `${base}${plan.path}`,
+        {
+          portfolio_links: items.map((item) => {
+            const [itemEncId, rest] = splitItemEncId(item);
+            return { encId: mode === "update" ? itemEncId : null, ...rest };
+          })
+        },
+        freshIdempotencyKey()
+      );
+      return;
+    }
+  }
+}
+async function attemptStep(section, run) {
+  try {
+    await run();
+    return { section, ok: true };
+  } catch (err) {
+    return { section, ok: false, error: describeError(err) };
+  }
+}
+async function createAggregate(opts, aggregate) {
+  const encId = await createShell(opts);
+  const reports = [];
+  if (aggregate.name !== void 0) {
+    reports.push(await attemptStep("name", () => renameResume(opts, encId, aggregate.name)));
+  }
+  for (const section of SECTIONS) {
+    const value = aggregate[section.key];
+    if (value === void 0) continue;
+    reports.push(await attemptStep(section.key, () => writeSection(opts, encId, section.key, value, "create")));
+  }
+  return { enc_id: encId, reports, allOk: reports.every((r) => r.ok) };
+}
+async function updateAggregate(opts, encId, aggregate, onlySection) {
+  const reports = [];
+  if (onlySection !== void 0) {
+    const section = getSection(onlySection);
+    if (!section) {
+      const allowed = SECTIONS.map((s) => s.key).join(", ");
+      throw new CliError(`Unknown section "${onlySection}". Allowed: ${allowed}`, ExitCode.InvalidArgument);
+    }
+    const value = aggregate[onlySection];
+    if (value === void 0) {
+      throw new CliError(`Section "${onlySection}" has no data in the input file`, ExitCode.InvalidArgument);
+    }
+    reports.push(await attemptStep(section.key, () => writeSection(opts, encId, section.key, value, "update")));
+    return { enc_id: encId, reports, allOk: reports.every((r) => r.ok) };
+  }
+  if (aggregate.name !== void 0) {
+    reports.push(await attemptStep("name", () => renameResume(opts, encId, aggregate.name)));
+  }
+  for (const section of SECTIONS) {
+    const value = aggregate[section.key];
+    if (value === void 0) continue;
+    reports.push(await attemptStep(section.key, () => writeSection(opts, encId, section.key, value, "update")));
+  }
+  return { enc_id: encId, reports, allOk: reports.every((r) => r.ok) };
+}
+
+// src/commands/personal/resumes/create.ts
+async function runResumesCreate(ctx, filePath) {
+  const input = readJsonObject(filePath, { timeoutMs: ctx.timeoutMs });
+  const issues = validateAggregate(input);
+  if (issues.length > 0) {
+    if (ctx.format === "json") {
+      printJson({ valid: false, issues });
+    } else {
+      for (const issue of issues) {
+        process.stderr.write(`${sanitizeForTerminal(issue.path)}: ${sanitizeForTerminal(issue.message)}
+`);
+      }
+    }
+    throw new CliError(`${issues.length} validation issue(s) found \u2014 fix locally before creating (no request sent)`, ExitCode.InvalidArgument);
+  }
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const result = await createAggregate(opts, input);
+  printOrchestrationResult(ctx, result);
+  if (!result.allOk) {
+    const failed = result.reports.filter((r) => !r.ok).map((r) => r.section);
+    throw new CliError(
+      `Resume ${result.enc_id} was created but ${failed.length} section(s) failed to write: ${failed.join(", ")}. Run \`wport personal resumes update ${result.enc_id} --section <name> --file <file>\` to retry the failed section(s).`,
+      ExitCode.ServerClientError
+    );
+  }
+}
+function printOrchestrationResult(ctx, result) {
+  if (ctx.format === "json") {
+    printJson({ enc_id: result.enc_id, reports: result.reports, all_ok: result.allOk });
+    return;
+  }
+  process.stdout.write(`Resume: ${sanitizeForTerminal(result.enc_id ?? "")}
+`);
+  printTable(
+    result.reports,
+    [
+      { header: "SECTION", value: (r) => r.section, maxWidth: 20 },
+      { header: "STATUS", value: (r) => r.ok ? "\u2713" : "\u2717" },
+      { header: "ERROR", value: (r) => r.error ?? "", maxWidth: 60 }
+    ],
+    ctx.color
+  );
+}
+function registerPersonalResumesCreate(parent) {
+  parent.command("create").description('Create a resume from a JSON aggregate file (validates locally first; use "-" for stdin)').requiredOption("--file <path>", 'path to a JSON resume aggregate, or "-" for stdin').action(async (flags, command) => {
+    await runResumesCreate(resolveContext(command), flags.file);
+  });
+}
+
+// src/commands/personal/resumes/update.ts
+function requireEncId2(encId) {
+  const trimmed = encId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  }
+  return trimmed;
+}
+async function runResumesUpdate(ctx, encId, filePath, flags) {
+  const trimmed = requireEncId2(encId);
+  const input = readJsonObject(filePath, { timeoutMs: ctx.timeoutMs });
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const result = await updateAggregate(opts, trimmed, input, flags.section);
+  printOrchestrationResult2(ctx, result);
+  if (!result.allOk) {
+    const failed = result.reports.filter((r) => !r.ok).map((r) => r.section);
+    throw new CliError(
+      `Resume ${result.enc_id} was partially updated \u2014 ${failed.length} section(s) failed: ${failed.join(", ")}. Fix the input and retry with --section <name>.`,
+      ExitCode.ServerClientError
+    );
+  }
+}
+function printOrchestrationResult2(ctx, result) {
+  if (ctx.format === "json") {
+    printJson({ enc_id: result.enc_id, reports: result.reports, all_ok: result.allOk });
+    return;
+  }
+  process.stdout.write(`Resume: ${sanitizeForTerminal(result.enc_id ?? "")}
+`);
+  printTable(
+    result.reports,
+    [
+      { header: "SECTION", value: (r) => r.section, maxWidth: 20 },
+      { header: "STATUS", value: (r) => r.ok ? "\u2713" : "\u2717" },
+      { header: "ERROR", value: (r) => r.error ?? "", maxWidth: 60 }
+    ],
+    ctx.color
+  );
+}
+function registerPersonalResumesUpdate(parent) {
+  parent.command("update <enc_id>").description("Update a resume aggregate (whole file, or one section with --section)").requiredOption("--file <path>", 'path to a JSON resume aggregate (or single-section content), or "-" for stdin').option("--section <name>", "only write this section (e.g. education, work_experience)").action(async (encId, flags, command) => {
+    await runResumesUpdate(resolveContext(command), encId, flags.file, flags);
+  });
+}
+
+// src/commands/personal/resumes/copy.ts
+var import_node_crypto12 = require("crypto");
+function requireEncId3(encId) {
+  const trimmed = encId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  }
+  return trimmed;
+}
+function printCopyResult(ctx, sourceEncId, newEncId) {
+  if (ctx.format === "json") {
+    printJson({ enc_id: newEncId });
+    return;
+  }
+  process.stdout.write(`Copied resume ${sanitizeForTerminal(sourceEncId)} \u2192 new resume: ${sanitizeForTerminal(newEncId)}
+`);
+}
+async function runResumesCopy(ctx, encId, name) {
+  const trimmed = requireEncId3(encId);
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const { body } = await personalPost(opts, `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(trimmed)}/duplicate`, {}, { idempotencyKey: (0, import_node_crypto12.randomUUID)() });
+  const { enc_id: newEncId } = unwrapDataResponse(body);
+  printCopyResult(ctx, trimmed, newEncId);
+  if (name === void 0) return;
+  try {
+    await personalPut(opts, `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(newEncId)}/name`, { name }, { idempotencyKey: (0, import_node_crypto12.randomUUID)() });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new CliError(
+      `Resume ${trimmed} was copied to ${newEncId}, but renaming it to "${name}" failed: ${reason}. The copy exists under its server-assigned default name \u2014 this CLI has no standalone rename command in v1.`,
+      ExitCode.ServerClientError
+    );
+  }
+}
+function registerPersonalResumesCopy(parent) {
+  parent.command("copy <enc_id>").description("Duplicate a resume (counts toward your resume limit)").option("--name <name>", "rename the new copy after duplicating").action(async (encId, flags, command) => {
+    await runResumesCopy(resolveContext(command), encId, flags.name);
+  });
+}
+
+// src/commands/personal/resumes/publish.ts
+var import_node_crypto13 = require("crypto");
+function requireEncId4(encId) {
+  const trimmed = encId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  }
+  return trimmed;
+}
+async function runResumesPublishTransition(ctx, encId, action) {
+  const trimmed = requireEncId4(encId);
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  const targetStatus = action === "publish";
+  const { body } = await personalPatch(
+    opts,
+    `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(trimmed)}/published-status`,
+    { target_status: targetStatus },
+    { idempotencyKey: (0, import_node_crypto13.randomUUID)() }
+  );
+  const result = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson({ enc_id: trimmed, is_published: result.is_published });
+    return;
+  }
+  const verb = action === "publish" ? "Published" : "Unpublished";
+  process.stdout.write(`${verb} resume: ${sanitizeForTerminal(trimmed)}
+`);
+}
+function registerPersonalResumesPublish(parent) {
+  parent.command("publish <enc_id>").description("Publish a resume (make it visible to employers)").action(async (encId, _flags, command) => {
+    await runResumesPublishTransition(resolveContext(command), encId, "publish");
+  });
+}
+function registerPersonalResumesUnpublish(parent) {
+  parent.command("unpublish <enc_id>").description("Unpublish a resume (hide it from employers)").action(async (encId, _flags, command) => {
+    await runResumesPublishTransition(resolveContext(command), encId, "unpublish");
+  });
+}
+
+// src/commands/personal/resumes/delete.ts
+var import_node_crypto14 = require("crypto");
+function requireEncId5(encId) {
+  const trimmed = encId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  }
+  return trimmed;
+}
+async function runResumesDelete(ctx, encId, confirm) {
+  if (!confirm) {
+    throw new CliError("Refusing to delete without --confirm (destructive, irreversible)", ExitCode.InvalidArgument);
+  }
+  const trimmed = requireEncId5(encId);
+  const opts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs };
+  await personalDelete(opts, `${PERSONAL_RESUMES_BASE}/${encodeURIComponent(trimmed)}`, { idempotencyKey: (0, import_node_crypto14.randomUUID)() });
+  if (ctx.format === "json") {
+    printJson({ enc_id: trimmed, deleted: true });
+    return;
+  }
+  process.stdout.write(`Deleted resume: ${sanitizeForTerminal(trimmed)}
+`);
+}
+function registerPersonalResumesDelete(parent) {
+  parent.command("delete <enc_id>").description("Delete a resume (destructive; requires --confirm)").option("--confirm", "confirm this destructive, irreversible delete").action(async (encId, flags, command) => {
+    await runResumesDelete(resolveContext(command), encId, flags.confirm === true);
+  });
+}
+
+// src/commands/personal/resumes/index.ts
+function registerPersonalResumesCommand(parent) {
+  const resumes = parent.command("resumes").description("Manage your personal resumes");
+  registerPersonalResumesSchema(resumes);
+  registerPersonalResumesValidate(resumes);
+  registerPersonalResumesTemplate(resumes);
+  registerPersonalResumesList(resumes);
+  registerPersonalResumesView(resumes);
+  registerPersonalResumesExport(resumes);
+  registerPersonalResumesCreate(resumes);
+  registerPersonalResumesUpdate(resumes);
+  registerPersonalResumesCopy(resumes);
+  registerPersonalResumesPublish(resumes);
+  registerPersonalResumesUnpublish(resumes);
+  registerPersonalResumesDelete(resumes);
+}
+
+// src/commands/personal/index.ts
+function registerPersonalCommand(program2) {
+  const personal = program2.command("personal").description("Manage your personal resumes and profile");
+  registerPersonalResumesCommand(personal);
+}
+
 // src/index.ts
 var program = new import_commander.Command();
-program.name("wport").description("wport CLI \u2014 terminal interface to the W101 Talent Search Hub public API").version("0.7.0", "-v, --version", "output the CLI version").option("--lang <locale>", "Accept-Language locale: zh-TW | en-US | vi-VN | th-TH | id-ID").option("--api <url>", "override API base URL").option("--output <fmt>", "output format: table | json").option("--no-color", "disable color output").option("--timeout <ms>", "HTTP timeout in milliseconds", (v) => Number(v));
+program.name("wport").description("wport CLI \u2014 terminal interface to the W101 Talent Search Hub public API").version("0.8.0", "-v, --version", "output the CLI version").option("--lang <locale>", "Accept-Language locale: zh-TW | en-US | vi-VN | th-TH | id-ID").option("--api <url>", "override API base URL").option("--output <fmt>", "output format: table | json").option("--no-color", "disable color output").option("--timeout <ms>", "HTTP timeout in milliseconds", (v) => Number(v));
 registerJobsCommand(program);
 registerConfigCommand(program);
 registerDoctorCommand(program);
 registerEnterpriseCommand(program);
+registerLoginCommand(program);
+registerWhoamiCommand(program);
+registerLogoutCommand(program);
+registerSessionsCommand(program);
+registerPersonalCommand(program);
 program.exitOverride();
 program.parseAsync(process.argv).then(() => process.exit(ExitCode.Success)).catch((err) => handleTopLevelError(err));
 function handleTopLevelError(err) {