@amadeus-dlc/setup 0.1.0

package/dist/cli.js

@@ -0,0 +1,2250 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "node:fs";
+import { dirname as dirname4, join as join10, resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/domain/command.ts
+import { parseArgs } from "node:util";
+
+// src/shared/result.ts
+var Result;
+((Result) => {
+  function ok(value) {
+    return Object.freeze({ type: "ok", value });
+  }
+  Result.ok = ok;
+  function err(error) {
+    return Object.freeze({ type: "err", error });
+  }
+  Result.err = err;
+})(Result ||= {});
+Object.freeze(Result);
+
+// src/domain/harness.ts
+var HarnessName;
+((HarnessName) => {
+  HarnessName.all = Object.freeze([
+    "claude",
+    "codex",
+    "kiro",
+    "kiro-ide"
+  ]);
+  function parse(raw) {
+    if (HarnessName.all.includes(raw)) {
+      return Result.ok(raw);
+    }
+    return Result.err(Object.freeze({ raw }));
+  }
+  HarnessName.parse = parse;
+})(HarnessName ||= {});
+Object.freeze(HarnessName);
+
+// src/internal/version-spec-factory.ts
+function createVersionSpec(kind, exactVersion) {
+  return Object.freeze({
+    kind,
+    admits(candidate) {
+      if (kind === "latest") {
+        return candidate.isStable();
+      }
+      return exactVersion !== null && candidate.equals(exactVersion);
+    },
+    describe() {
+      return kind === "latest" ? "latest stable version" : `version ${exactVersion?.format() ?? "?"}`;
+    }
+  });
+}
+
+// src/internal/semver-factory.ts
+function createSemVer(major, minor, patch, prerelease) {
+  return Object.freeze({
+    major,
+    minor,
+    patch,
+    prerelease,
+    isStable() {
+      return prerelease === null;
+    },
+    isLaterThan(other) {
+      if (major !== other.major)
+        return major > other.major;
+      if (minor !== other.minor)
+        return minor > other.minor;
+      if (patch !== other.patch)
+        return patch > other.patch;
+      return false;
+    },
+    equals(other) {
+      return major === other.major && minor === other.minor && patch === other.patch && prerelease === other.prerelease;
+    },
+    format() {
+      return prerelease ? `v${major}.${minor}.${patch}-${prerelease}` : `v${major}.${minor}.${patch}`;
+    }
+  });
+}
+
+// src/domain/semver.ts
+var SEMVER_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+var SemVer;
+((SemVer) => {
+  function parse(raw) {
+    const match = SEMVER_PATTERN.exec(raw.trim());
+    if (!match) {
+      return Result.err(VersionError.invalidFormat(raw, "expected MAJOR.MINOR.PATCH[-PRERELEASE], optionally prefixed with 'v'"));
+    }
+    const [, majorRaw, minorRaw, patchRaw, prerelease] = match;
+    return Result.ok(createSemVer(Number(majorRaw), Number(minorRaw), Number(patchRaw), prerelease ?? null));
+  }
+  SemVer.parse = parse;
+  function latestStableOf(list) {
+    let best;
+    for (const candidate of list) {
+      if (!candidate.isStable())
+        continue;
+      if (!best || candidate.isLaterThan(best))
+        best = candidate;
+    }
+    return best;
+  }
+  SemVer.latestStableOf = latestStableOf;
+})(SemVer ||= {});
+Object.freeze(SemVer);
+var VersionError;
+((VersionError) => {
+  function invalidFormat(raw, reason) {
+    return Object.freeze({ type: "invalid-format", raw, reason });
+  }
+  VersionError.invalidFormat = invalidFormat;
+})(VersionError ||= {});
+Object.freeze(VersionError);
+
+// src/domain/version-spec.ts
+var VersionSpec;
+((VersionSpec) => {
+  function latest() {
+    return createVersionSpec("latest", null);
+  }
+  VersionSpec.latest = latest;
+  function exact(raw) {
+    const parsed = SemVer.parse(raw);
+    if (parsed.type === "err")
+      return parsed;
+    return Result.ok(createVersionSpec("exact", parsed.value));
+  }
+  VersionSpec.exact = exact;
+})(VersionSpec ||= {});
+Object.freeze(VersionSpec);
+
+// src/domain/command.ts
+var UsageError;
+((UsageError) => {
+  function unknownSubcommand(raw) {
+    return Object.freeze({ type: "unknown-subcommand", raw });
+  }
+  UsageError.unknownSubcommand = unknownSubcommand;
+  function unknownFlag(raw) {
+    return Object.freeze({ type: "unknown-flag", raw });
+  }
+  UsageError.unknownFlag = unknownFlag;
+  function invalidHarness(raw) {
+    return Object.freeze({ type: "invalid-harness", raw });
+  }
+  UsageError.invalidHarness = invalidHarness;
+  function multipleHarnesses(raws) {
+    return Object.freeze({ type: "multiple-harnesses", raws });
+  }
+  UsageError.multipleHarnesses = multipleHarnesses;
+  function missingRequired(fields) {
+    return Object.freeze({ type: "missing-required", fields });
+  }
+  UsageError.missingRequired = missingRequired;
+  function invalidVersion(cause) {
+    return Object.freeze({ type: "invalid-version", cause });
+  }
+  UsageError.invalidVersion = invalidVersion;
+})(UsageError ||= {});
+Object.freeze(UsageError);
+function createParsedCommand(state) {
+  return Object.freeze({
+    ...state,
+    isNonInteractive(stdinIsTty) {
+      return state.yes || !stdinIsTty;
+    },
+    missingRequiredFor(_mode) {
+      const missing = [];
+      if (state.harness === null)
+        missing.push("harness");
+      if (state.target === null)
+        missing.push("target");
+      return missing;
+    }
+  });
+}
+var ParsedCommand;
+((ParsedCommand) => {
+  function parse(argv) {
+    const [rawSubcommand, ...rest] = argv;
+    if (rawSubcommand === undefined) {
+      return Result.ok(createParsedCommand({
+        subcommand: "help",
+        harness: null,
+        target: null,
+        version: VersionSpec.latest(),
+        yes: false,
+        force: false
+      }));
+    }
+    if (rawSubcommand !== "install" && rawSubcommand !== "upgrade") {
+      return Result.err(UsageError.unknownSubcommand(rawSubcommand));
+    }
+    let values;
+    try {
+      const parsed = parseArgs({
+        args: rest,
+        options: {
+          harness: { type: "string", multiple: true },
+          target: { type: "string" },
+          version: { type: "string" },
+          yes: { type: "boolean", default: false },
+          force: { type: "boolean", default: false }
+        },
+        strict: true,
+        allowPositionals: false
+      });
+      values = parsed.values;
+    } catch (cause) {
+      return Result.err(UsageError.unknownFlag(describeParseArgsFailure(cause)));
+    }
+    const harnessRaws = values.harness ?? [];
+    if (harnessRaws.length > 1) {
+      return Result.err(UsageError.multipleHarnesses(harnessRaws));
+    }
+    let harness = null;
+    if (harnessRaws.length === 1) {
+      const parsedHarness = HarnessName.parse(harnessRaws[0]);
+      if (parsedHarness.type === "err")
+        return Result.err(UsageError.invalidHarness(parsedHarness.error.raw));
+      harness = parsedHarness.value;
+    }
+    let version = VersionSpec.latest();
+    if (values.version !== undefined) {
+      const parsedVersion = VersionSpec.exact(values.version);
+      if (parsedVersion.type === "err")
+        return Result.err(UsageError.invalidVersion(parsedVersion.error));
+      version = parsedVersion.value;
+    }
+    return Result.ok(createParsedCommand({
+      subcommand: rawSubcommand,
+      harness,
+      target: values.target ?? null,
+      version,
+      yes: values.yes === true,
+      force: values.force === true
+    }));
+  }
+  ParsedCommand.parse = parse;
+})(ParsedCommand ||= {});
+Object.freeze(ParsedCommand);
+function describeParseArgsFailure(cause) {
+  if (cause instanceof Error) {
+    const match = /'(--?[^']+)'/.exec(cause.message);
+    if (match)
+      return match[1];
+    return cause.message;
+  }
+  return String(cause);
+}
+var InstallInputs;
+((InstallInputs) => {
+  function fromFlags(parsed) {
+    if (parsed.harness === null || parsed.target === null) {
+      throw new Error("InstallInputs.fromFlags requires harness and target to already be resolved (BR-I03 precondition)");
+    }
+    return Object.freeze({ harness: parsed.harness, target: parsed.target });
+  }
+  InstallInputs.fromFlags = fromFlags;
+})(InstallInputs ||= {});
+Object.freeze(InstallInputs);
+
+// src/domain/installation.ts
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/domain/engine-layout.ts
+var ENGINE_DIR_BY_HARNESS = Object.freeze({
+  claude: ".claude",
+  codex: ".codex",
+  kiro: ".kiro",
+  "kiro-ide": ".kiro"
+});
+function engineDirNameFor(harness) {
+  const dir = ENGINE_DIR_BY_HARNESS[harness];
+  if (dir === undefined) {
+    throw new Error(`no engine directory mapping is defined for harness "${harness}"`);
+  }
+  return dir;
+}
+function allEngineDirNames() {
+  return Object.freeze([...new Set(Object.values(ENGINE_DIR_BY_HARNESS))]);
+}
+
+// src/domain/installation.ts
+var Installation;
+((Installation) => {
+  async function detect(target, manifestIo) {
+    const manifestResult = await manifestIo.read(target);
+    if (manifestResult.type === "ok" && manifestResult.value !== null) {
+      return manifestedInstallation(manifestResult.value);
+    }
+    const evidence = await scanEvidence(target);
+    if (evidence.paths.length === 0) {
+      return noneInstallation();
+    }
+    const missing = [];
+    if (!evidence.anchors.toolsDir)
+      missing.push("tools directory");
+    if (!evidence.anchors.amadeusCommon)
+      missing.push("amadeus-common directory");
+    if (missing.length > 0) {
+      return partialInstallation(missing);
+    }
+    return manualOrUnknownInstallation(evidence);
+  }
+  Installation.detect = detect;
+})(Installation ||= {});
+Object.freeze(Installation);
+function admissionFor(kind, force, detected) {
+  if (kind === "none")
+    return Object.freeze({ type: "proceed" });
+  if (force)
+    return Object.freeze({ type: "proceed-forced" });
+  return Object.freeze({ type: "refuse-suggest-upgrade", detected });
+}
+function noneInstallation() {
+  return Object.freeze({
+    kind: "none",
+    admitsInstall(force) {
+      return admissionFor("none", force, "");
+    }
+  });
+}
+function manifestedInstallation(manifest) {
+  const detected = `${manifest.harness} ${manifest.sourceTag} (installed ${manifest.installedAt})`;
+  return Object.freeze({
+    kind: "manifested",
+    manifest,
+    admitsInstall(force) {
+      return admissionFor("manifested", force, detected);
+    }
+  });
+}
+function manualOrUnknownInstallation(evidence) {
+  const detected = `a manual or unrecognized Amadeus installation (found: ${evidence.paths.join(", ")})`;
+  return Object.freeze({
+    kind: "manual-or-unknown",
+    evidence,
+    admitsInstall(force) {
+      return admissionFor("manual-or-unknown", force, detected);
+    }
+  });
+}
+function partialInstallation(missing) {
+  const detected = `a partial Amadeus installation (missing: ${missing.join(", ")})`;
+  return Object.freeze({
+    kind: "partial",
+    missing,
+    admitsInstall(force) {
+      return admissionFor("partial", force, detected);
+    }
+  });
+}
+async function scanEvidence(target) {
+  const paths = [];
+  let toolsDir = false;
+  let amadeusCommon = false;
+  let versionFileContent = null;
+  for (const engineDir of allEngineDirNames()) {
+    const hasToolsDir = await dirExists(join(target, engineDir, "tools"));
+    const hasAmadeusCommon = await dirExists(join(target, engineDir, "amadeus-common"));
+    let versionContent = null;
+    try {
+      versionContent = await readFile(join(target, engineDir, "VERSION"), "utf8");
+    } catch {}
+    if (!hasToolsDir && !hasAmadeusCommon && versionContent === null)
+      continue;
+    if (hasToolsDir) {
+      paths.push(`${engineDir}/tools`);
+      toolsDir = true;
+    }
+    if (hasAmadeusCommon) {
+      paths.push(`${engineDir}/amadeus-common`);
+      amadeusCommon = true;
+    }
+    if (versionContent !== null && versionFileContent === null) {
+      versionFileContent = versionContent;
+      paths.push(`${engineDir}/VERSION`);
+    }
+  }
+  return Object.freeze({
+    paths: Object.freeze(paths),
+    versionFileContent,
+    anchors: Object.freeze({ toolsDir, amadeusCommon })
+  });
+}
+async function dirExists(path) {
+  try {
+    const info = await stat(path);
+    return info.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/internal/manifest-files-factory.ts
+function createManifestFiles(entries) {
+  const byPath = new Map(entries.map((entry) => [entry.path, entry]));
+  return Object.freeze({
+    requiredPaths() {
+      return entries.filter((entry) => entry.required).map((entry) => entry.path);
+    },
+    dispositionFor(path, actualMd5) {
+      const entry = byPath.get(path);
+      if (!entry || entry.class === "owned") {
+        return Object.freeze({ type: "overwrite" });
+      }
+      if (entry.class === "user-preserved") {
+        return Object.freeze({ type: "preserve" });
+      }
+      return actualMd5 === entry.md5 ? Object.freeze({ type: "overwrite" }) : Object.freeze({ type: "backup-then-copy" });
+    },
+    entries() {
+      return entries;
+    }
+  });
+}
+
+// src/internal/manifest-factory.ts
+function createManifest(state) {
+  return Object.freeze({
+    schemaVersion: 1,
+    installerPackageVersion: state.installerPackageVersion,
+    distributionVersion: state.distributionVersion,
+    sourceTag: state.sourceTag,
+    installedAt: state.installedAt,
+    harness: state.harness,
+    dispositionFor(path, actualMd5) {
+      return state.files.dispositionFor(path, actualMd5);
+    },
+    isNewerThan(candidate) {
+      return state.distributionVersion.isLaterThan(candidate);
+    },
+    requiredPaths() {
+      return state.files.requiredPaths();
+    },
+    upgradedTo(next) {
+      return createManifest({
+        installerPackageVersion: next.meta.installerPackageVersion,
+        distributionVersion: next.payload.version.semver,
+        sourceTag: next.payload.version.tag,
+        installedAt: next.meta.installStartedAt,
+        harness: next.meta.harness,
+        files: next.files
+      });
+    },
+    toJSON() {
+      return Object.freeze({
+        schemaVersion: 1,
+        installerPackageVersion: state.installerPackageVersion,
+        distributionVersion: state.distributionVersion.format(),
+        sourceTag: state.sourceTag,
+        installedAt: state.installedAt,
+        harness: state.harness,
+        files: state.files.entries().map((entry) => ({
+          path: entry.path,
+          class: entry.class,
+          required: entry.required,
+          md5: entry.md5
+        }))
+      });
+    }
+  });
+}
+
+// src/domain/manifest.ts
+var ManifestFiles;
+((ManifestFiles) => {
+  function fromEntries(entries) {
+    const seen = new Set;
+    for (const entry of entries) {
+      if (seen.has(entry.path))
+        return Result.err(ManifestError.duplicatePath(entry.path));
+      seen.add(entry.path);
+    }
+    return Result.ok(createManifestFiles(entries));
+  }
+  ManifestFiles.fromEntries = fromEntries;
+})(ManifestFiles ||= {});
+Object.freeze(ManifestFiles);
+var Manifest;
+((Manifest) => {
+  function parse(json) {
+    return parseManifestJson(json);
+  }
+  Manifest.parse = parse;
+  function build(payload, files, meta) {
+    return createManifest({
+      installerPackageVersion: meta.installerPackageVersion,
+      distributionVersion: payload.version.semver,
+      sourceTag: payload.version.tag,
+      installedAt: meta.installStartedAt,
+      harness: meta.harness,
+      files
+    });
+  }
+  Manifest.build = build;
+})(Manifest ||= {});
+Object.freeze(Manifest);
+var ManifestError;
+((ManifestError) => {
+  function schemaUnsupported(found) {
+    return Object.freeze({ type: "schema-unsupported", found });
+  }
+  ManifestError.schemaUnsupported = schemaUnsupported;
+  function malformed(detail) {
+    return Object.freeze({ type: "malformed", detail });
+  }
+  ManifestError.malformed = malformed;
+  function unknownHarness(raw) {
+    return Object.freeze({ type: "unknown-harness", raw });
+  }
+  ManifestError.unknownHarness = unknownHarness;
+  function duplicatePath(path) {
+    return Object.freeze({ type: "duplicate-path", path });
+  }
+  ManifestError.duplicatePath = duplicatePath;
+  function io(detail) {
+    return Object.freeze({ type: "io", detail });
+  }
+  ManifestError.io = io;
+})(ManifestError ||= {});
+Object.freeze(ManifestError);
+function parseManifestJson(json) {
+  if (typeof json !== "object" || json === null) {
+    return Result.err(ManifestError.malformed("expected a JSON object"));
+  }
+  const obj = json;
+  if (obj.schemaVersion !== 1) {
+    return Result.err(ManifestError.schemaUnsupported(obj.schemaVersion));
+  }
+  const { installerPackageVersion, distributionVersion: distributionVersionRaw, sourceTag, installedAt, harness: harnessRaw, files: filesRaw } = obj;
+  if (typeof installerPackageVersion !== "string" || typeof distributionVersionRaw !== "string" || typeof sourceTag !== "string" || typeof installedAt !== "string" || typeof harnessRaw !== "string" || !Array.isArray(filesRaw)) {
+    return Result.err(ManifestError.malformed("one or more required fields are missing or the wrong type"));
+  }
+  if (!sourceTag.startsWith("v")) {
+    return Result.err(ManifestError.malformed(`sourceTag must start with "v", got ${sourceTag}`));
+  }
+  if (!HarnessName.all.includes(harnessRaw)) {
+    return Result.err(ManifestError.unknownHarness(harnessRaw));
+  }
+  const distributionVersion = SemVer.parse(distributionVersionRaw);
+  if (distributionVersion.type === "err") {
+    return Result.err(ManifestError.malformed(`invalid distributionVersion: ${distributionVersion.error.reason}`));
+  }
+  const parsedFiles = [];
+  for (const entry of filesRaw) {
+    const parsedEntry = parseManifestFile(entry);
+    if (parsedEntry === null) {
+      return Result.err(ManifestError.malformed("a files[] entry is missing a required field or has the wrong type"));
+    }
+    parsedFiles.push(parsedEntry);
+  }
+  const files = ManifestFiles.fromEntries(parsedFiles);
+  if (files.type === "err")
+    return files;
+  return Result.ok(createManifest({
+    installerPackageVersion,
+    distributionVersion: distributionVersion.value,
+    sourceTag,
+    installedAt,
+    harness: harnessRaw,
+    files: files.value
+  }));
+}
+function parseManifestFile(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return null;
+  const e = entry;
+  if (typeof e.path !== "string" || typeof e.md5 !== "string" || typeof e.required !== "boolean")
+    return null;
+  if (e.class !== "owned" && e.class !== "shared" && e.class !== "user-preserved")
+    return null;
+  return { path: e.path, class: e.class, required: e.required, md5: e.md5 };
+}
+
+// src/domain/plan.ts
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, openSync, readSync, readdirSync, statSync } from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+
+// src/shared/timestamps.ts
+var Timestamps;
+((Timestamps) => {
+  function of(now) {
+    const iso = now.toISOString();
+    const token = iso.replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+    return Object.freeze({ iso, token });
+  }
+  Timestamps.of = of;
+})(Timestamps ||= {});
+Object.freeze(Timestamps);
+
+// src/domain/plan.ts
+var PlanRefusal;
+((PlanRefusal) => {
+  function alreadyInstalled(admission) {
+    return Object.freeze({ type: "already-installed", admission });
+  }
+  PlanRefusal.alreadyInstalled = alreadyInstalled;
+  function harnessNotInPayload(harness) {
+    return Object.freeze({ type: "harness-not-in-payload", harness });
+  }
+  PlanRefusal.harnessNotInPayload = harnessNotInPayload;
+})(PlanRefusal ||= {});
+Object.freeze(PlanRefusal);
+function createPlan(entries, startedAtIso, backupTimestamp, root) {
+  return Object.freeze({
+    startedAtIso,
+    backupTimestamp,
+    entries() {
+      return entries;
+    },
+    entriesBy(action) {
+      return entries.filter((entry) => entry.action === action);
+    },
+    hasConflicts() {
+      return entries.some((entry) => entry.action === "conflict");
+    },
+    isNoop() {
+      return entries.every((entry) => entry.action === "skip");
+    },
+    summary() {
+      return Object.freeze({
+        add: entries.filter((entry) => entry.action === "add").length,
+        update: entries.filter((entry) => entry.action === "update").length,
+        skip: entries.filter((entry) => entry.action === "skip").length,
+        backup: entries.filter((entry) => entry.action === "backup").length,
+        conflict: entries.filter((entry) => entry.action === "conflict").length
+      });
+    },
+    harnessRoot() {
+      return root;
+    }
+  });
+}
+var Plan;
+((Plan) => {
+  function forInstall(payload, harness, target, opts) {
+    const rootResult = payload.harnessRoot(harness);
+    if (rootResult.type === "err") {
+      return Result.err(PlanRefusal.harnessNotInPayload(harness));
+    }
+    const entries = buildEntries(rootResult.value, target, opts);
+    const { iso, token } = Timestamps.of(new Date(opts.startedAt));
+    return Result.ok(createPlan(entries, iso, token, rootResult.value));
+  }
+  Plan.forInstall = forInstall;
+  function forUpgrade(payload, source, harness, target, opts) {
+    const rootResult = payload.harnessRoot(harness);
+    if (rootResult.type === "err") {
+      return Result.err(PlanRefusal.harnessNotInPayload(harness));
+    }
+    const entries = buildUpgradeEntries(rootResult.value, target, source, opts);
+    const { iso, token } = Timestamps.of(new Date(opts.startedAt));
+    return Result.ok(createPlan(entries, iso, token, rootResult.value));
+  }
+  Plan.forUpgrade = forUpgrade;
+})(Plan ||= {});
+Object.freeze(Plan);
+function buildEntries(root, target, opts) {
+  const entries = [];
+  for (const relPath of walkFiles(root)) {
+    const cls = classify(relPath);
+    const exists = existsSync(join2(target, relPath));
+    const action = classifyAction(exists, opts.force, cls);
+    entries.push(Object.freeze({
+      path: relPath,
+      action,
+      class: cls,
+      forced: action === "update" || action === "backup",
+      md5: md5OfFileSync(join2(root, relPath)),
+      required: cls === "owned"
+    }));
+  }
+  return entries;
+}
+function classifyAction(exists, force, cls) {
+  if (!exists)
+    return "add";
+  if (!force)
+    return "conflict";
+  if (cls === "owned")
+    return "update";
+  if (cls === "user-preserved")
+    return "skip";
+  return "backup";
+}
+function buildUpgradeEntries(root, target, source, opts) {
+  const entries = [];
+  for (const relPath of walkFiles(root)) {
+    const cls = classify(relPath);
+    const newMd5 = md5OfFileSync(join2(root, relPath));
+    if (!existsSync(join2(target, relPath))) {
+      entries.push(Object.freeze({ path: relPath, action: "add", class: cls, forced: false, md5: newMd5, required: cls === "owned" }));
+      continue;
+    }
+    const actualMd5 = md5OfFileSync(join2(target, relPath));
+    const disposition = source.dispositionFor(relPath, cls, actualMd5);
+    const action = toPlanAction(disposition);
+    entries.push(Object.freeze({
+      path: relPath,
+      action,
+      class: cls,
+      forced: opts.force && disposition.type === "backup-then-copy",
+      md5: newMd5,
+      required: cls === "owned"
+    }));
+  }
+  return entries;
+}
+function toPlanAction(disposition) {
+  switch (disposition.type) {
+    case "overwrite":
+      return "update";
+    case "backup-then-copy":
+      return "backup";
+    case "preserve":
+      return "skip";
+  }
+}
+function classify(relPath) {
+  const segments = relPath.split("/");
+  const basename = segments[segments.length - 1] ?? relPath;
+  if (basename.startsWith("amadeus-"))
+    return "owned";
+  if (segments.includes("memory"))
+    return "user-preserved";
+  return "shared";
+}
+function walkFiles(root) {
+  const results = [];
+  function walk(dir) {
+    for (const name of readdirSync(dir)) {
+      const full = join2(dir, name);
+      if (statSync(full).isDirectory()) {
+        walk(full);
+      } else {
+        results.push(relative(root, full).split(sep).join("/"));
+      }
+    }
+  }
+  walk(root);
+  return results;
+}
+var MD5_CHUNK_SIZE = 64 * 1024;
+function md5OfFileSync(path) {
+  const fd = openSync(path, "r");
+  const hash = createHash("md5");
+  const buffer = Buffer.alloc(MD5_CHUNK_SIZE);
+  try {
+    for (;; ) {
+      const bytesRead = readSync(fd, buffer, 0, MD5_CHUNK_SIZE, null);
+      if (bytesRead === 0)
+        break;
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return hash.digest("hex");
+}
+
+// src/domain/upgrade.ts
+function createUpgradeAssessment(outcome) {
+  return Object.freeze({
+    outcome() {
+      return outcome;
+    },
+    isActionable() {
+      return outcome.type === "proceed";
+    }
+  });
+}
+var UpgradeAssessment;
+((UpgradeAssessment) => {
+  function of(installed, resolved, spec) {
+    if (installed.equals(resolved.semver)) {
+      return createUpgradeAssessment({ type: "already-up-to-date", installed });
+    }
+    if (resolved.semver.isLaterThan(installed)) {
+      return createUpgradeAssessment({ type: "proceed", to: resolved });
+    }
+    if (spec.kind === "latest") {
+      return createUpgradeAssessment({ type: "installed-newer-than-latest", installed, latest: resolved.semver });
+    }
+    return createUpgradeAssessment({ type: "downgrade-unsupported", installed, requested: resolved.semver });
+  }
+  UpgradeAssessment.of = of;
+})(UpgradeAssessment ||= {});
+Object.freeze(UpgradeAssessment);
+var UpgradeRefusal;
+((UpgradeRefusal) => {
+  function fromOutcome(outcome) {
+    return outcome;
+  }
+  UpgradeRefusal.fromOutcome = fromOutcome;
+  function noInstallation() {
+    return Object.freeze({ type: "no-installation" });
+  }
+  UpgradeRefusal.noInstallation = noInstallation;
+  function unsupportedLayout(detail) {
+    return Object.freeze({ type: "unsupported-layout", detail });
+  }
+  UpgradeRefusal.unsupportedLayout = unsupportedLayout;
+  function partialRefused(missing) {
+    return Object.freeze({ type: "partial-refused", missing });
+  }
+  UpgradeRefusal.partialRefused = partialRefused;
+})(UpgradeRefusal ||= {});
+Object.freeze(UpgradeRefusal);
+var LegacyLayout;
+((LegacyLayout) => {
+  function isUnsupported(evidence) {
+    if (evidence.versionFileContent !== null) {
+      const parsed = SemVer.parse(evidence.versionFileContent);
+      if (parsed.type === "err") {
+        return Object.freeze({
+          unsupported: true,
+          detail: `VERSION file content predates the current versioning convention: ${evidence.versionFileContent.trim()}`
+        });
+      }
+    }
+    const hasAmadeusPrefixedPath = evidence.paths.some((path) => {
+      const segments = path.split("/");
+      const basename = segments[segments.length - 1] ?? path;
+      return basename.startsWith("amadeus-");
+    });
+    if (hasAmadeusPrefixedPath && !evidence.anchors.toolsDir && !evidence.anchors.amadeusCommon) {
+      return Object.freeze({
+        unsupported: true,
+        detail: "amadeus-* files were found without either current layout anchor (tools/ or amadeus-common/) present"
+      });
+    }
+    return Object.freeze({ unsupported: false, detail: "" });
+  }
+  LegacyLayout.isUnsupported = isUnsupported;
+})(LegacyLayout ||= {});
+Object.freeze(LegacyLayout);
+function manifestedSource(manifest) {
+  return Object.freeze({
+    kind: "manifested",
+    dispositionFor(path, _cls, actualMd5) {
+      return manifest.dispositionFor(path, actualMd5);
+    },
+    assess(resolved, spec) {
+      return UpgradeAssessment.of(manifest.distributionVersion, resolved, spec);
+    },
+    nextManifest(input) {
+      return manifest.upgradedTo(input);
+    },
+    strategyNote() {
+      return `Upgrading a manifest-tracked ${manifest.harness} installation from ${manifest.sourceTag}.`;
+    }
+  });
+}
+function conservativeSource(kind) {
+  return Object.freeze({
+    kind,
+    dispositionFor(_path, cls, _actualMd5) {
+      if (cls === "owned")
+        return Object.freeze({ type: "overwrite" });
+      if (cls === "user-preserved")
+        return Object.freeze({ type: "preserve" });
+      return Object.freeze({ type: "backup-then-copy" });
+    },
+    assess(_resolved, _spec) {
+      return null;
+    },
+    nextManifest(input) {
+      return Manifest.build(input.payload, input.files, input.meta);
+    },
+    strategyNote() {
+      return kind === "manual-or-unknown" ? "No installer manifest was found; using a conservative strategy that backs up every modified shared file before copying." : "Partial installation forced with --force; proceeding with the same conservative backup strategy.";
+    }
+  });
+}
+var UpgradeSource;
+((UpgradeSource) => {
+  function fromInstallation(installation, force) {
+    if (installation.kind === "none") {
+      return Result.err(UpgradeRefusal.noInstallation());
+    }
+    if (installation.kind === "partial") {
+      if (!force)
+        return Result.err(UpgradeRefusal.partialRefused(installation.missing));
+      return Result.ok(conservativeSource("partial-forced"));
+    }
+    if (installation.kind === "manual-or-unknown") {
+      const verdict = LegacyLayout.isUnsupported(installation.evidence);
+      if (verdict.unsupported)
+        return Result.err(UpgradeRefusal.unsupportedLayout(verdict.detail));
+      return Result.ok(conservativeSource("manual-or-unknown"));
+    }
+    return Result.ok(manifestedSource(installation.manifest));
+  }
+  UpgradeSource.fromInstallation = fromInstallation;
+})(UpgradeSource ||= {});
+Object.freeze(UpgradeSource);
+
+// src/domain/verify-result.ts
+var VerifyResult;
+((VerifyResult) => {
+  function of(checks) {
+    return Object.freeze({
+      allPassed() {
+        return checks.every((check) => check.ok);
+      },
+      failures() {
+        return checks.filter((check) => !check.ok);
+      },
+      checks() {
+        return checks;
+      }
+    });
+  }
+  VerifyResult.of = of;
+})(VerifyResult ||= {});
+Object.freeze(VerifyResult);
+var NextSteps;
+((NextSteps) => {
+  function of(harness, version, target) {
+    return Object.freeze({
+      harness,
+      version,
+      target,
+      lines() {
+        return Object.freeze([
+          `Installed ${harness} ${version.tag} to ${target}.`,
+          "Next steps:",
+          `  1. cd ${target}`,
+          "  2. Open your AI harness and run /amadeus (or the equivalent slash command).",
+          "  3. Describe what you want to build — the engine starts your first intent automatically."
+        ]);
+      }
+    });
+  }
+  NextSteps.of = of;
+})(NextSteps ||= {});
+Object.freeze(NextSteps);
+
+// src/modules/applier.ts
+import { dirname, join as join3, resolve, sep as sep2 } from "node:path";
+var Applier;
+((Applier) => {
+  function create(fsWrite) {
+    return Object.freeze({
+      async apply(plan, target) {
+        const targetRoot = resolve(target);
+        const applied = [];
+        const backupPaths = [];
+        const failures = [];
+        const madeDirs = new Set;
+        for (const entry of plan.entries()) {
+          if (entry.action === "skip") {
+            applied.push(entry);
+            continue;
+          }
+          const disposition = dispositionFor(entry);
+          if (disposition === "skip") {
+            applied.push(entry);
+            continue;
+          }
+          const destResult = resolveWithin(targetRoot, entry.path, "copy");
+          if (destResult.type === "err") {
+            failures.push(destResult.error);
+            break;
+          }
+          const dest = destResult.value;
+          const destDir = dirname(dest);
+          if (!madeDirs.has(destDir)) {
+            const mkdirResult = await fsWrite.mkdir(destDir);
+            if (mkdirResult.type === "err") {
+              failures.push({ path: entry.path, operation: "mkdir", detail: mkdirResult.error.detail });
+              break;
+            }
+            madeDirs.add(destDir);
+          }
+          if (disposition === "backup-then-copy" && await fsWrite.exists(dest)) {
+            const backupResult = resolveWithin(targetRoot, `${entry.path}.${plan.backupTimestamp}.bk`, "backup");
+            if (backupResult.type === "err") {
+              failures.push(backupResult.error);
+              break;
+            }
+            const bkPath = backupResult.value;
+            if (await fsWrite.exists(bkPath)) {
+              failures.push({ path: entry.path, operation: "backup", detail: `backup path already exists: ${entry.path}.${plan.backupTimestamp}.bk` });
+              break;
+            }
+            const backedUp = await fsWrite.backup(dest, bkPath);
+            if (backedUp.type === "err") {
+              failures.push({ path: entry.path, operation: "backup", detail: backedUp.error.detail });
+              break;
+            }
+            backupPaths.push(`${entry.path}.${plan.backupTimestamp}.bk`);
+          }
+          const copied = await fsWrite.copyFile(join3(plan.harnessRoot(), entry.path), dest);
+          if (copied.type === "err") {
+            failures.push({ path: entry.path, operation: "copy", detail: copied.error.detail });
+            break;
+          }
+          applied.push(entry);
+        }
+        return Object.freeze({
+          hasFailures() {
+            return failures.length > 0;
+          },
+          failures() {
+            return failures;
+          },
+          appliedEntries() {
+            return applied;
+          },
+          backupPaths() {
+            return backupPaths;
+          },
+          manifestFiles() {
+            return ManifestFiles.fromEntries(applied.map((entry) => ({ path: entry.path, class: entry.class, required: entry.required, md5: entry.md5 })));
+          }
+        });
+      }
+    });
+  }
+  Applier.create = create;
+})(Applier ||= {});
+Object.freeze(Applier);
+function dispositionFor(entry) {
+  if (entry.action === "add" || entry.action === "update")
+    return "copy";
+  if (entry.action === "backup")
+    return "backup-then-copy";
+  if (entry.class === "owned")
+    return "copy";
+  if (entry.class === "user-preserved")
+    return "skip";
+  return "backup-then-copy";
+}
+function resolveWithin(targetRoot, relPath, operation) {
+  const resolved = resolve(targetRoot, relPath);
+  if (resolved !== targetRoot && !resolved.startsWith(`${targetRoot}${sep2}`)) {
+    return Result.err({ path: relPath, operation, detail: `resolved path escapes the install target: ${relPath}` });
+  }
+  return Result.ok(resolved);
+}
+
+// src/modules/manifest-io.ts
+import { join as join4 } from "node:path";
+var MANIFEST_RELATIVE_PATH = join4("amadeus", ".installer", "amadeus-setup-manifest.json");
+function createManifestIo(fsRead, fsWrite) {
+  return Object.freeze({
+    async read(targetDir) {
+      const path = join4(targetDir, MANIFEST_RELATIVE_PATH);
+      const contents = await fsRead.readText(path);
+      if (contents.type === "err") {
+        if (contents.error.notFound)
+          return Result.ok(null);
+        return Result.err(ManifestError.io(contents.error.detail));
+      }
+      let json;
+      try {
+        json = JSON.parse(contents.value);
+      } catch (cause) {
+        return Result.err(ManifestError.malformed(`manifest is not valid JSON: ${String(cause)}`));
+      }
+      return Manifest.parse(json);
+    },
+    async write(targetDir, manifest) {
+      const path = join4(targetDir, MANIFEST_RELATIVE_PATH);
+      const written = await fsWrite.writeText(path, JSON.stringify(manifest.toJSON(), null, 2));
+      if (written.type === "err")
+        return Result.err(ManifestError.io(written.error.detail));
+      return Result.ok(undefined);
+    }
+  });
+}
+
+// src/modules/reporter.ts
+function renderHelp() {
+  return [
+    "amadeus-setup",
+    "",
+    "Usage:",
+    "  amadeus-setup install [--harness <claude|codex|kiro|kiro-ide>] [--target <path>] [--version <semver|tag>] [--yes] [--force]",
+    "  amadeus-setup upgrade [--harness <claude|codex|kiro|kiro-ide>] [--target <path>] [--version <semver|tag>] [--yes] [--force]",
+    "  amadeus-setup            # this help; install/upgrade are never run implicitly"
+  ].join(`
+`);
+}
+var ACTION_LABELS = {
+  add: "Add",
+  update: "Update",
+  skip: "Skip",
+  backup: "Backup then copy",
+  conflict: "Conflict (needs confirmation)"
+};
+function renderPlanReport(plan, note) {
+  const lines = [];
+  if (note !== undefined)
+    lines.push(note, "");
+  lines.push("Plan:");
+  const actionsInReportOrder = ["add", "update", "backup", "conflict", "skip"];
+  for (const action of actionsInReportOrder) {
+    const entries = plan.entriesBy(action);
+    if (entries.length === 0)
+      continue;
+    lines.push(`  ${ACTION_LABELS[action]}:`);
+    for (const entry of entries) {
+      lines.push(`    ${entry.path}${entry.forced ? " (forced)" : ""}`);
+    }
+  }
+  const summary = plan.summary();
+  lines.push(`Summary: add=${summary.add} update=${summary.update} backup=${summary.backup} conflict=${summary.conflict} skip=${summary.skip}`);
+  return lines.join(`
+`);
+}
+function renderAlreadyInstalled(admission) {
+  if (admission.type !== "refuse-suggest-upgrade") {
+    return "Amadeus is already installed here.";
+  }
+  return [
+    `Amadeus is already installed here (${admission.detected}).`,
+    "Run `amadeus-setup upgrade` instead, or pass --force to reinstall."
+  ].join(`
+`);
+}
+function renderApplyFailure(applied) {
+  const lines = ["Install failed while applying files:"];
+  for (const failure of applied.failures()) {
+    lines.push(`  [${failure.operation}] ${failure.path}: ${failure.detail}`);
+  }
+  lines.push("No manifest was written; re-run once the issue above is resolved.");
+  return lines.join(`
+`);
+}
+function renderVerifyFailure(verify) {
+  const lines = ["Verification failed after install:"];
+  for (const check of verify.failures()) {
+    lines.push(`  [${check.name}] ${check.detail}`);
+  }
+  return lines.join(`
+`);
+}
+function renderSuccess(_applied, verify, next) {
+  const lines = ["Install complete.", "", "Verification:"];
+  for (const check of verify.checks()) {
+    lines.push(`  [${check.ok ? "ok" : "FAIL"}] ${check.name}: ${check.detail}`);
+  }
+  lines.push("", ...next.lines());
+  return lines.join(`
+`);
+}
+function renderWizardAborted() {
+  return "Install aborted: selection was not confirmed. No files were changed.";
+}
+function renderTmpDirFailure(detail) {
+  return `could not prepare a temp directory: ${detail}`;
+}
+function renderError(err) {
+  if (isFetchErrorLike(err)) {
+    return [`Network error (${err.type}): ${err.detail}`, err.guidance()].join(`
+`);
+  }
+  switch (err.type) {
+    case "unknown-subcommand":
+      return `Unknown command: "${err.raw}". Run \`amadeus-setup\` with no arguments for usage.`;
+    case "unknown-flag":
+      return `Unknown option: ${err.raw}. Run \`amadeus-setup\` with no arguments for usage.`;
+    case "invalid-harness":
+      return `Invalid --harness value: "${err.raw}". Expected one of claude, codex, kiro, kiro-ide.`;
+    case "multiple-harnesses":
+      return `Only one --harness is supported per run (got: ${err.raws.join(", ")}). Run once per harness.`;
+    case "missing-required":
+      return `Missing required option(s) in non-interactive mode: ${err.fields.join(", ")}.`;
+    case "invalid-version":
+      return `Invalid --version value: "${err.cause.raw}" (${err.cause.reason}).`;
+    case "no-stable-version":
+      return `Could not resolve a version to install: ${err.detail}`;
+    case "not-found":
+      return `Requested version not found: ${err.requested}`;
+    case "schema-unsupported":
+      return "The existing installer manifest uses an unsupported schema version.";
+    case "malformed":
+      return `The existing installer manifest is malformed: ${err.detail}`;
+    case "unknown-harness":
+      return `The existing installer manifest references an unknown harness: "${err.raw}".`;
+    case "duplicate-path":
+      return `Internal error: duplicate manifest path "${err.path}".`;
+    case "io":
+      return `I/O error: ${err.detail}`;
+    case "already-installed":
+      return renderAlreadyInstalled(err.admission);
+    case "harness-not-in-payload":
+      return `The requested harness "${err.harness}" is not present in this distribution.`;
+    case "no-installation":
+      return "No Amadeus installation was found here. Run `amadeus-setup install` instead.";
+    case "unsupported-layout":
+      return `This installation cannot be upgraded: ${err.detail}. No files were changed.`;
+    case "partial-refused":
+      return `A partial Amadeus installation was found (missing: ${err.missing.join(", ")}). Re-run with --force to proceed conservatively, or restore the missing files first.`;
+    case "already-up-to-date":
+      return `Already up to date: the installed version (${err.installed.format()}) matches the requested version.`;
+    case "downgrade-unsupported":
+      return `Cannot downgrade: requested ${err.requested.format()} is older than the installed version ${err.installed.format()}.`;
+    case "installed-newer-than-latest":
+      return `The installed version (${err.installed.format()}) is newer than the latest resolved version (${err.latest.format()}). Pass --version to target a specific release.`;
+    default:
+      return "An unexpected error occurred.";
+  }
+}
+function isFetchErrorLike(err) {
+  return typeof err.guidance === "function";
+}
+
+// src/modules/fetcher.ts
+import { join as join7 } from "node:path";
+
+// src/internal/tar-archive-extractor.ts
+import { createGunzip } from "node:zlib";
+import { createReadStream } from "node:fs";
+import { join as join6, sep as sep3 } from "node:path";
+
+// src/internal/payload-factory.ts
+import { readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/internal/fetch-error-factory.ts
+var GUIDANCE = {
+  dns: "Check your network connection and try again.",
+  conn: "Check your network connection and try again.",
+  timeout: "The request timed out; try again on a more stable connection.",
+  http: "The GitHub archive could not be retrieved; verify the requested version exists.",
+  "rate-limit": "GitHub API rate limit reached; wait a while before retrying.",
+  "payload-invalid": "The downloaded archive is not a valid Amadeus distribution."
+};
+function createFetchError(type, detail, status = null) {
+  return Object.freeze({
+    type,
+    detail,
+    status,
+    isTransient() {
+      switch (type) {
+        case "dns":
+        case "conn":
+        case "timeout":
+          return true;
+        case "http":
+          return status !== null && status >= 500;
+        case "rate-limit":
+        case "payload-invalid":
+          return false;
+        default: {
+          const exhaustive = type;
+          throw new Error(`unreachable FetchErrorType: ${exhaustive}`);
+        }
+      }
+    },
+    guidance() {
+      return GUIDANCE[type];
+    }
+  });
+}
+
+// src/internal/payload-factory.ts
+function resolveWrapperDir(extractedDir) {
+  let entries;
+  try {
+    entries = readdirSync2(extractedDir);
+  } catch (cause) {
+    return Result.err(createFetchError("payload-invalid", `could not read extracted archive at ${extractedDir}: ${String(cause)}`));
+  }
+  const dirs = entries.filter((name) => statSync2(join5(extractedDir, name)).isDirectory());
+  if (dirs.length !== 1) {
+    return Result.err(createFetchError("payload-invalid", `expected exactly one top-level directory in the extracted archive, found ${dirs.length}`));
+  }
+  return Result.ok(join5(extractedDir, dirs[0]));
+}
+function createExtractedPayload(extractedDir, version, harnessNames) {
+  const wrapper = resolveWrapperDir(extractedDir);
+  if (wrapper.type === "err")
+    return wrapper;
+  const distDir = join5(wrapper.value, "dist");
+  let distEntries;
+  try {
+    distEntries = readdirSync2(distDir);
+  } catch {
+    return Result.err(createFetchError("payload-invalid", `missing dist/ directory in extracted archive (expected ${distDir})`));
+  }
+  const available = harnessNames.filter((name) => distEntries.includes(name) && statSync2(join5(distDir, name)).isDirectory());
+  return Result.ok(Object.freeze({
+    version,
+    harnessRoot(harness) {
+      if (!available.includes(harness)) {
+        return Result.err(createFetchError("payload-invalid", `harness "${harness}" is not present in this distribution`));
+      }
+      return Result.ok(join5(distDir, harness));
+    },
+    availableHarnesses() {
+      return available;
+    }
+  }));
+}
+
+// src/domain/payload.ts
+var FetchError;
+((FetchError) => {
+  function classify2(cause, meta) {
+    const type = classifyType(cause, meta);
+    return createFetchError(type, describeCause(cause, meta), meta?.status ?? null);
+  }
+  FetchError.classify = classify2;
+  function payloadInvalid(detail) {
+    return createFetchError("payload-invalid", detail, null);
+  }
+  FetchError.payloadInvalid = payloadInvalid;
+})(FetchError ||= {});
+Object.freeze(FetchError);
+function classifyType(cause, meta) {
+  if (meta?.status === 403 || meta?.status === 429)
+    return "rate-limit";
+  if (meta && meta.status !== null && meta.status >= 400)
+    return "http";
+  if (isTimeoutError(cause))
+    return "timeout";
+  if (isDnsError(cause))
+    return "dns";
+  return "conn";
+}
+function isTimeoutError(cause) {
+  return cause instanceof Error && (cause.name === "TimeoutError" || cause.name === "AbortError");
+}
+function isDnsError(cause) {
+  return cause instanceof Error && "code" in cause && cause.code === "ENOTFOUND";
+}
+function describeCause(cause, meta) {
+  if (meta)
+    return `${meta.url} responded with status ${meta.status ?? "unknown"}`;
+  if (cause instanceof Error)
+    return cause.message;
+  return String(cause);
+}
+var ExtractedPayload;
+((ExtractedPayload) => {
+  function locate(extractedDir, version) {
+    return createExtractedPayload(extractedDir, version, HarnessName.all);
+  }
+  ExtractedPayload.locate = locate;
+})(ExtractedPayload ||= {});
+Object.freeze(ExtractedPayload);
+
+// src/internal/tar-archive-extractor.ts
+var EXTRACT_RELATIVE_DIR = "extracted";
+var BLOCK_SIZE = 512;
+async function extractTarGz(archivePath, extractDir, tmpWrite) {
+  const gunzip = createReadStream(archivePath).pipe(createGunzip());
+  let carry = Buffer.alloc(0);
+  let pendingLongName = null;
+  let current = null;
+  try {
+    for await (const chunk of gunzip) {
+      const bufferChunk = Buffer.from(chunk);
+      carry = carry.length > 0 ? Buffer.concat([carry, bufferChunk]) : bufferChunk;
+      const result2 = await drain(false);
+      if (result2)
+        return result2;
+    }
+    const result = await drain(true);
+    if (result)
+      return result;
+  } catch (cause) {
+    return Result.err(FetchError.payloadInvalid(`archive is not valid gzip/tar: ${String(cause)}`));
+  }
+  return Result.ok(undefined);
+  async function drain(final) {
+    for (;; ) {
+      if (current) {
+        const take = Math.min(current.remaining, carry.length);
+        if (take > 0) {
+          current.chunks.push(carry.subarray(0, take));
+          carry = carry.subarray(take);
+          current.remaining -= take;
+        }
+        if (current.remaining > 0) {
+          if (final)
+            return Result.err(FetchError.payloadInvalid("truncated tar entry"));
+          return null;
+        }
+        const dataLen = current.chunks.reduce((n, b) => n + b.length, 0);
+        const pad = paddingFor(dataLen);
+        if (carry.length < pad) {
+          if (final)
+            return Result.err(FetchError.payloadInvalid("truncated tar padding"));
+          return null;
+        }
+        carry = carry.subarray(pad);
+        const written = await tmpWrite.writeFile(current.path, Buffer.concat(current.chunks));
+        if (written.type === "err") {
+          return Result.err(FetchError.payloadInvalid(`could not write extracted file: ${written.error.detail}`));
+        }
+        current = null;
+        continue;
+      }
+      if (carry.length < BLOCK_SIZE) {
+        if (final && carry.length > 0)
+          return Result.err(FetchError.payloadInvalid("truncated tar header"));
+        return null;
+      }
+      const block = carry.subarray(0, BLOCK_SIZE);
+      carry = carry.subarray(BLOCK_SIZE);
+      if (isZeroBlock(block))
+        continue;
+      const header = parseHeader(block);
+      if (!header)
+        return Result.err(FetchError.payloadInvalid("malformed tar header"));
+      if (header.typeflag === "x" || header.typeflag === "g") {
+        const pad = paddingFor(header.size);
+        if (carry.length < header.size + pad) {
+          if (final)
+            return Result.err(FetchError.payloadInvalid("truncated PAX header"));
+          return null;
+        }
+        const paxData = carry.subarray(0, header.size);
+        carry = carry.subarray(header.size + pad);
+        if (header.typeflag === "x")
+          pendingLongName = parsePaxPath(paxData) ?? pendingLongName;
+        continue;
+      }
+      if (header.typeflag === "L") {
+        const pad = paddingFor(header.size);
+        if (carry.length < header.size + pad) {
+          if (final)
+            return Result.err(FetchError.payloadInvalid("truncated GNU long-name header"));
+          return null;
+        }
+        pendingLongName = carry.subarray(0, header.size).toString("utf8").replace(/\0+$/, "");
+        carry = carry.subarray(header.size + pad);
+        continue;
+      }
+      const rawName = pendingLongName ?? header.name;
+      pendingLongName = null;
+      if (header.typeflag === "5" || rawName.endsWith("/")) {
+        const validated2 = validateEntry(rawName, extractDir);
+        if (validated2.type === "err")
+          return validated2;
+        const dirResult = await tmpWrite.mkdir(validated2.value);
+        if (dirResult.type === "err") {
+          return Result.err(FetchError.payloadInvalid(`could not create directory: ${dirResult.error.detail}`));
+        }
+        continue;
+      }
+      if (header.typeflag !== "0" && header.typeflag !== "\x00") {
+        return Result.err(FetchError.payloadInvalid(`unsupported tar entry type "${header.typeflag}" for ${rawName}`));
+      }
+      const validated = validateEntry(rawName, extractDir);
+      if (validated.type === "err")
+        return validated;
+      if (header.size === 0) {
+        const written = await tmpWrite.writeFile(validated.value, Buffer.alloc(0));
+        if (written.type === "err") {
+          return Result.err(FetchError.payloadInvalid(`could not write extracted file: ${written.error.detail}`));
+        }
+        continue;
+      }
+      current = { path: validated.value, remaining: header.size, chunks: [] };
+    }
+  }
+}
+function validateEntry(rawName, extractDir) {
+  if (rawName.length === 0) {
+    return Result.err(FetchError.payloadInvalid("tar entry has an empty name"));
+  }
+  if (isAbsolutePath(rawName)) {
+    return Result.err(FetchError.payloadInvalid(`tar entry has an absolute path: ${rawName}`));
+  }
+  const relative2 = rawName.replace(/\/+$/, "");
+  const resolved = join6(extractDir, relative2);
+  if (resolved !== extractDir && !resolved.startsWith(`${extractDir}${sep3}`)) {
+    return Result.err(FetchError.payloadInvalid(`tar entry escapes the extraction root: ${rawName}`));
+  }
+  return Result.ok(join6(EXTRACT_RELATIVE_DIR, relative2));
+}
+function isAbsolutePath(name) {
+  return name.startsWith("/") || name.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(name);
+}
+function parseHeader(block) {
+  const name = readCString(block, 0, 100);
+  const sizeRaw = readCString(block, 124, 12);
+  const typeflagByte = block[156] ?? 0;
+  const prefix = readCString(block, 345, 155);
+  const size = parseOctal(sizeRaw);
+  if (size === null)
+    return null;
+  const fullName = prefix ? `${prefix}/${name}` : name;
+  const typeflag = typeflagByte === 0 ? "\x00" : String.fromCharCode(typeflagByte);
+  return { name: fullName, size, typeflag };
+}
+function readCString(block, offset, length) {
+  const slice = block.subarray(offset, offset + length);
+  const zeroIdx = slice.indexOf(0);
+  const trimmed = zeroIdx === -1 ? slice : slice.subarray(0, zeroIdx);
+  return trimmed.toString("utf8");
+}
+function parseOctal(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0)
+    return 0;
+  if (!/^[0-7]+$/.test(trimmed))
+    return null;
+  return Number.parseInt(trimmed, 8);
+}
+function isZeroBlock(block) {
+  return block.every((byte) => byte === 0);
+}
+function paddingFor(dataLen) {
+  const remainder = dataLen % BLOCK_SIZE;
+  return remainder === 0 ? 0 : BLOCK_SIZE - remainder;
+}
+function parsePaxPath(data) {
+  let offset = 0;
+  while (offset < data.length) {
+    const spaceIdx = data.indexOf(32, offset);
+    if (spaceIdx === -1)
+      break;
+    const lenStr = data.subarray(offset, spaceIdx).toString("utf8");
+    const len = Number.parseInt(lenStr, 10);
+    if (!Number.isFinite(len) || len <= 0)
+      break;
+    const record = data.subarray(offset, offset + len).toString("utf8");
+    const eq = record.indexOf("=");
+    if (eq !== -1) {
+      const key = record.slice(lenStr.length + 1, eq);
+      if (key === "path")
+        return record.slice(eq + 1).replace(/\n$/, "");
+    }
+    offset += len;
+  }
+  return null;
+}
+
+// src/modules/fetcher.ts
+var ARCHIVE_RELATIVE_PATH = "archive.tar.gz";
+function createFetcher(http, tmpWrite) {
+  async function downloadOnce(url) {
+    const response = await http.downloadArchive(url);
+    if (response.type === "err")
+      return response;
+    const written = await tmpWrite.writeStream(ARCHIVE_RELATIVE_PATH, response.value);
+    if (written.type === "err") {
+      return Result.err(FetchError.payloadInvalid(`could not save downloaded archive: ${written.error.detail}`));
+    }
+    return Result.ok(undefined);
+  }
+  return Object.freeze({
+    async fetchArchive(version) {
+      const url = version.archiveUrl();
+      let downloaded = await downloadOnce(url);
+      if (downloaded.type === "err") {
+        if (!downloaded.error.isTransient())
+          return downloaded;
+        downloaded = await downloadOnce(url);
+        if (downloaded.type === "err")
+          return downloaded;
+      }
+      const archivePath = join7(tmpWrite.root, ARCHIVE_RELATIVE_PATH);
+      const extractDir = join7(tmpWrite.root, EXTRACT_RELATIVE_DIR);
+      const extraction = await extractTarGz(archivePath, extractDir, tmpWrite);
+      if (extraction.type === "err")
+        return extraction;
+      return ExtractedPayload.locate(extractDir, version);
+    }
+  });
+}
+
+// src/internal/resolved-version-factory.ts
+var CODELOAD_BASE = "https://codeload.github.com/amadeus-dlc/amadeus/tar.gz/refs/tags";
+function createResolvedVersion(semver, source) {
+  const tag = semver.format();
+  return Object.freeze({
+    tag,
+    semver,
+    source,
+    archiveUrl() {
+      return new URL(`${CODELOAD_BASE}/${tag}`);
+    },
+    isSameAs(other) {
+      return semver.equals(other);
+    }
+  });
+}
+
+// src/domain/resolved-version.ts
+var ResolvedVersion;
+((ResolvedVersion) => {
+  function fromRelease(semver) {
+    return createResolvedVersion(semver, "release");
+  }
+  ResolvedVersion.fromRelease = fromRelease;
+  function fromTag(semver) {
+    return createResolvedVersion(semver, "tag");
+  }
+  ResolvedVersion.fromTag = fromTag;
+})(ResolvedVersion ||= {});
+Object.freeze(ResolvedVersion);
+var ResolveError;
+((ResolveError) => {
+  function noStableVersion(detail = "no stable release or tag was found") {
+    return Object.freeze({ type: "no-stable-version", detail });
+  }
+  ResolveError.noStableVersion = noStableVersion;
+  function notFound(spec) {
+    return Object.freeze({ type: "not-found", requested: spec.describe() });
+  }
+  ResolveError.notFound = notFound;
+})(ResolveError ||= {});
+Object.freeze(ResolveError);
+
+// src/modules/resolver.ts
+var RELEASES_PATH = "/repos/amadeus-dlc/amadeus/releases";
+var TAGS_PATH = "/repos/amadeus-dlc/amadeus/tags";
+function createResolver(http) {
+  async function fetchNames(apiPath, nameField, includeEntry = () => true) {
+    const response = await http.getJson(apiPath);
+    if (response.type === "err")
+      return response;
+    if (!Array.isArray(response.value)) {
+      return Result.err(FetchError.payloadInvalid(`GitHub API response at ${apiPath} was not an array`));
+    }
+    const names = response.value.filter(includeEntry).map((entry) => entry[nameField]).filter((name) => typeof name === "string");
+    return Result.ok(names);
+  }
+  function fetchTagNames() {
+    return fetchNames(TAGS_PATH, "name");
+  }
+  function fetchReleaseTagNames() {
+    return fetchNames(RELEASES_PATH, "tag_name", (entry) => entry.draft !== true && entry.prerelease !== true);
+  }
+  function parseAllStable(names) {
+    const parsed = [];
+    for (const name of names) {
+      const result = SemVer.parse(name);
+      if (result.type === "ok")
+        parsed.push(result.value);
+    }
+    return parsed;
+  }
+  return Object.freeze({
+    async resolveVersion(spec) {
+      if (spec.kind === "exact") {
+        const tagNames2 = await fetchTagNames();
+        if (tagNames2.type === "err")
+          return tagNames2;
+        const hit = parseAllStable(tagNames2.value).find((candidate) => spec.admits(candidate));
+        return hit ? Result.ok(ResolvedVersion.fromTag(hit)) : Result.err(ResolveError.notFound(spec));
+      }
+      const releaseTagNames = await fetchReleaseTagNames();
+      if (releaseTagNames.type === "err")
+        return releaseTagNames;
+      const bestRelease = SemVer.latestStableOf(parseAllStable(releaseTagNames.value));
+      if (bestRelease)
+        return Result.ok(ResolvedVersion.fromRelease(bestRelease));
+      const tagNames = await fetchTagNames();
+      if (tagNames.type === "err")
+        return tagNames;
+      const bestTag = SemVer.latestStableOf(parseAllStable(tagNames.value));
+      if (bestTag)
+        return Result.ok(ResolvedVersion.fromTag(bestTag));
+      return Result.err(ResolveError.noStableVersion());
+    }
+  });
+}
+
+// src/modules/verifier.ts
+import { join as join8 } from "node:path";
+var Verifier;
+((Verifier) => {
+  function create(fsRead) {
+    return Object.freeze({
+      async verify(target, manifest) {
+        const checks = [];
+        const requiredPaths = manifest.requiredPaths();
+        const missing = [];
+        for (const path of requiredPaths) {
+          if (!await fsRead.fileExists(join8(target, path)))
+            missing.push(path);
+        }
+        checks.push({
+          name: "required-files",
+          ok: missing.length === 0,
+          detail: missing.length === 0 ? `all ${requiredPaths.length} required files are present` : `missing required files: ${missing.join(", ")}`
+        });
+        const engineDir = engineDirNameFor(manifest.harness);
+        const harnessDirOk = await fsRead.dirExists(join8(target, engineDir));
+        checks.push({
+          name: "harness-dir",
+          ok: harnessDirOk,
+          detail: harnessDirOk ? `${engineDir} exists` : `${engineDir} is missing`
+        });
+        const toolsDirOk = await fsRead.dirExists(join8(target, engineDir, "tools"));
+        checks.push({
+          name: "tools-dir",
+          ok: toolsDirOk,
+          detail: toolsDirOk ? `${engineDir}/tools exists` : `${engineDir}/tools is missing`
+        });
+        const memoryDirOk = await fsRead.dirExists(join8(target, "amadeus", "spaces", "default", "memory"));
+        checks.push({
+          name: "memory-shell",
+          ok: memoryDirOk,
+          detail: memoryDirOk ? "amadeus/spaces/default/memory exists" : "amadeus/spaces/default/memory is missing"
+        });
+        const activeIntentExists = await fsRead.fileExists(join8(target, "amadeus", "spaces", "default", "intents", "active-intent"));
+        checks.push({
+          name: "state-absence",
+          ok: true,
+          detail: activeIntentExists ? "an existing intent state was found and left untouched" : "no active intent state found (expected for a fresh install)"
+        });
+        return VerifyResult.of(checks);
+      }
+    });
+  }
+  Verifier.create = create;
+})(Verifier ||= {});
+Object.freeze(Verifier);
+
+// src/modules/wizard.ts
+async function runWizard(parsed, missing, tty) {
+  let harness = parsed.harness;
+  if (missing.includes("harness")) {
+    const selected = await tty.select("Select a harness to install", HarnessName.all);
+    const parsedHarness = HarnessName.parse(selected);
+    harness = parsedHarness.type === "ok" ? parsedHarness.value : parsed.harness;
+  }
+  let target = parsed.target;
+  if (missing.includes("target")) {
+    target = await tty.input("Install target directory", process.cwd());
+  }
+  if (harness === null || target === null) {
+    return Result.err("wizard-aborted");
+  }
+  const confirmed = await tty.confirm(summaryPrompt(parsed.subcommand, harness, target));
+  if (!confirmed) {
+    return Result.err("wizard-aborted");
+  }
+  return Result.ok(Object.freeze({ harness, target }));
+}
+function summaryPrompt(subcommand, harness, target) {
+  if (subcommand === "upgrade")
+    return `Upgrade ${harness} in ${target}?`;
+  return `Install ${harness} into ${target}?`;
+}
+
+// src/ports/apply-write.ts
+import { mkdir as mkdirAsync, copyFile as copyFileAsync, rename as renameAsync, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+
+// src/ports/fsops.ts
+import { createWriteStream } from "node:fs";
+import { mkdir, mkdtemp, readFile as readFile2, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, join as join9, resolve as resolve2 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var IoError;
+((IoError) => {
+  function of(detail, notFound = false) {
+    return Object.freeze({ type: "io", detail, notFound });
+  }
+  IoError.of = of;
+})(IoError ||= {});
+Object.freeze(IoError);
+function createFsRead() {
+  return Object.freeze({
+    async readText(path) {
+      try {
+        return Result.ok(await readFile2(path, "utf8"));
+      } catch (cause) {
+        return Result.err(IoError.of(`could not read ${path}: ${String(cause)}`, isEnoent(cause)));
+      }
+    }
+  });
+}
+function isEnoent(cause) {
+  return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+function createFsWrite() {
+  return Object.freeze({
+    async writeText(path, content) {
+      try {
+        await mkdir(dirname2(path), { recursive: true });
+        await writeFile(path, content, "utf8");
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not write ${path}: ${String(cause)}`));
+      }
+    }
+  });
+}
+async function createTmpWrite(prefix) {
+  let root;
+  try {
+    root = await mkdtemp(join9(tmpdir(), prefix));
+  } catch (cause) {
+    return Result.err(IoError.of(`could not create temp directory: ${String(cause)}`));
+  }
+  function resolveUnderRoot(relPath) {
+    const target = resolve2(root, relPath);
+    if (target !== root && !target.startsWith(`${root}/`)) {
+      throw new Error(`path escapes temp root: ${relPath}`);
+    }
+    return target;
+  }
+  return Result.ok(Object.freeze({
+    root,
+    async writeFile(relPath, data) {
+      try {
+        const target = resolveUnderRoot(relPath);
+        await mkdir(dirname2(target), { recursive: true });
+        await writeFile(target, data);
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not write ${relPath} under temp root: ${String(cause)}`));
+      }
+    },
+    async writeStream(relPath, stream) {
+      try {
+        const target = resolveUnderRoot(relPath);
+        await mkdir(dirname2(target), { recursive: true });
+        await pipeline(Readable.fromWeb(stream), createWriteStream(target));
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not stream ${relPath} under temp root: ${String(cause)}`));
+      }
+    },
+    async mkdir(relPath) {
+      try {
+        await mkdir(resolveUnderRoot(relPath), { recursive: true });
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not create directory ${relPath} under temp root: ${String(cause)}`));
+      }
+    },
+    async remove() {
+      await rm(root, { recursive: true, force: true });
+    }
+  }));
+}
+
+// src/ports/apply-write.ts
+function createApplyWrite() {
+  return Object.freeze({
+    async exists(path) {
+      try {
+        await stat2(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async mkdir(path) {
+      try {
+        await mkdirAsync(path, { recursive: true });
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not create directory ${path}: ${String(cause)}`));
+      }
+    },
+    async copyFile(src, dest) {
+      try {
+        await mkdirAsync(dirname3(dest), { recursive: true });
+        await copyFileAsync(src, dest);
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not copy ${src} to ${dest}: ${String(cause)}`));
+      }
+    },
+    async backup(path, backupPath) {
+      try {
+        await renameAsync(path, backupPath);
+        return Result.ok(undefined);
+      } catch (cause) {
+        return Result.err(IoError.of(`could not back up ${path} to ${backupPath}: ${String(cause)}`));
+      }
+    }
+  });
+}
+
+// src/ports/http.ts
+var ALLOWED_HOSTS = new Set(["api.github.com", "codeload.github.com"]);
+var API_BASE = "https://api.github.com";
+var MAX_REDIRECTS = 5;
+function createHttp(options) {
+  return Object.freeze({
+    async getJson(apiPath) {
+      const url = new URL(apiPath, API_BASE);
+      const checked = await fetchChecked(url, options.apiTimeoutMs);
+      if (checked.type === "err")
+        return checked;
+      return Result.ok(await checked.value.json());
+    },
+    async downloadArchive(url) {
+      const checked = await fetchChecked(url, options.archiveTimeoutMs);
+      if (checked.type === "err")
+        return checked;
+      const response = checked.value;
+      if (!response.body) {
+        return Result.err(FetchError.classify(new Error("empty response body"), { status: response.status, url: url.toString() }));
+      }
+      return Result.ok(response.body);
+    }
+  });
+}
+async function fetchChecked(url, timeoutMs) {
+  if (!ALLOWED_HOSTS.has(url.host)) {
+    return Result.err(FetchError.payloadInvalid(`refusing to contact untrusted host: ${url.host}`));
+  }
+  try {
+    const response = await fetchFollowingAllowedHosts(url, timeoutMs);
+    if (!response.ok) {
+      const meta = { status: response.status, url: url.toString() };
+      return Result.err(FetchError.classify(new Error(`HTTP ${response.status}`), meta));
+    }
+    return Result.ok(response);
+  } catch (cause) {
+    return Result.err(FetchError.classify(cause, { status: null, url: url.toString() }));
+  }
+}
+async function fetchFollowingAllowedHosts(initialUrl, timeoutMs) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  let current = initialUrl;
+  for (let hop = 0;hop <= MAX_REDIRECTS; hop++) {
+    const response = await fetch(current, { signal, redirect: "manual" });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      if (!location)
+        throw new Error(`redirect response ${response.status} had no Location header`);
+      const next = new URL(location, current);
+      if (!ALLOWED_HOSTS.has(next.host)) {
+        throw new Error(`refusing to follow redirect to untrusted host: ${next.host}`);
+      }
+      current = next;
+      continue;
+    }
+    return response;
+  }
+  throw new Error("too many redirects");
+}
+
+// src/ports/tty.ts
+import { createInterface } from "node:readline/promises";
+function createTtyIO() {
+  return Object.freeze({
+    isTTY: process.stdin.isTTY === true,
+    async select(prompt, options) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        const menu = options.map((option, index) => `  ${index + 1}) ${option}`).join(`
+`);
+        for (;; ) {
+          const answer = (await rl.question(`${prompt}
+${menu}
+Enter a number: `)).trim();
+          const index = Number.parseInt(answer, 10) - 1;
+          if (Number.isInteger(index) && index >= 0 && index < options.length) {
+            return options[index];
+          }
+        }
+      } finally {
+        rl.close();
+      }
+    },
+    async input(prompt, defaultValue) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        const answer = (await rl.question(`${prompt} [${defaultValue}]: `)).trim();
+        return answer.length === 0 ? defaultValue : answer;
+      } finally {
+        rl.close();
+      }
+    },
+    async confirm(prompt) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        const answer = (await rl.question(`${prompt} [y/N]: `)).trim().toLowerCase();
+        return answer === "y" || answer === "yes";
+      } finally {
+        rl.close();
+      }
+    }
+  });
+}
+
+// src/ports/verify-read.ts
+import { stat as stat3 } from "node:fs/promises";
+function createVerifyRead() {
+  return Object.freeze({
+    async fileExists(path) {
+      try {
+        const info = await stat3(path);
+        return info.isFile();
+      } catch {
+        return false;
+      }
+    },
+    async dirExists(path) {
+      try {
+        const info = await stat3(path);
+        return info.isDirectory();
+      } catch {
+        return false;
+      }
+    }
+  });
+}
+
+// src/cli.ts
+var PACKAGE_JSON_PATH = join10(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
+var SETUP_VERSION = JSON.parse(readFileSync(PACKAGE_JSON_PATH, "utf8")).version;
+var API_TIMEOUT_MS = 1e4;
+var ARCHIVE_TIMEOUT_MS = 30000;
+function createDefaultPorts() {
+  return Object.freeze({
+    tty: createTtyIO(),
+    manifestIo: createManifestIo(createFsRead(), createFsWrite()),
+    http: createHttp({ apiTimeoutMs: API_TIMEOUT_MS, archiveTimeoutMs: ARCHIVE_TIMEOUT_MS }),
+    createTmpWrite,
+    applyWrite: createApplyWrite(),
+    verifyRead: createVerifyRead()
+  });
+}
+async function main(argv, ports = createDefaultPorts()) {
+  const parsed = ParsedCommand.parse(argv);
+  if (parsed.type === "err") {
+    console.error(renderError(parsed.error));
+    return 2;
+  }
+  if (parsed.value.subcommand === "help") {
+    console.log(renderHelp());
+    return 0;
+  }
+  if (parsed.value.subcommand === "upgrade") {
+    return runUpgrade(parsed.value, ports);
+  }
+  return runInstall(parsed.value, ports);
+}
+async function resolveInputs(parsed, ports) {
+  const { tty } = ports;
+  const mode = parsed.isNonInteractive(tty.isTTY) ? "non-interactive" : "interactive";
+  const missing = parsed.missingRequiredFor(mode);
+  if (mode === "non-interactive") {
+    if (missing.length > 0) {
+      console.error(renderError(UsageError.missingRequired(missing)));
+      return { type: "exit", code: 2 };
+    }
+    return { type: "ok", inputs: InstallInputs.fromFlags(parsed), mode };
+  }
+  if (missing.length > 0) {
+    const wizardResult = await runWizard(parsed, missing, tty);
+    if (wizardResult.type === "err") {
+      console.log(renderWizardAborted());
+      return { type: "exit", code: 1 };
+    }
+    return { type: "ok", inputs: wizardResult.value, mode };
+  }
+  return { type: "ok", inputs: InstallInputs.fromFlags(parsed), mode };
+}
+async function withTmpWrite(ports, prefix, fn) {
+  const tmpWriteResult = await ports.createTmpWrite(prefix);
+  if (tmpWriteResult.type === "err") {
+    console.error(renderTmpDirFailure(tmpWriteResult.error.detail));
+    return 1;
+  }
+  const tmpWrite = tmpWriteResult.value;
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned)
+      return;
+    cleaned = true;
+    tmpWrite.remove();
+  };
+  const onSignal = () => {
+    cleanup();
+    process.exit(1);
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  try {
+    return await fn(tmpWrite);
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    cleanup();
+  }
+}
+async function runInstall(parsed, ports) {
+  const resolvedInputs = await resolveInputs(parsed, ports);
+  if (resolvedInputs.type === "exit")
+    return resolvedInputs.code;
+  const { inputs, mode } = resolvedInputs;
+  const installation = await Installation.detect(inputs.target, ports.manifestIo);
+  const admission = installation.admitsInstall(parsed.force);
+  if (admission.type === "refuse-suggest-upgrade") {
+    console.error(renderAlreadyInstalled(admission));
+    return 1;
+  }
+  const resolved = await createResolver(ports.http).resolveVersion(parsed.version);
+  if (resolved.type === "err") {
+    console.error(renderError(resolved.error));
+    return 1;
+  }
+  return withTmpWrite(ports, "amadeus-setup-install-", async (tmpWrite) => {
+    const fetched = await createFetcher(ports.http, tmpWrite).fetchArchive(resolved.value);
+    if (fetched.type === "err") {
+      console.error(renderError(fetched.error));
+      return 1;
+    }
+    const startedAt = new Date().toISOString();
+    const planResult = Plan.forInstall(fetched.value, inputs.harness, inputs.target, { force: parsed.force, startedAt });
+    if (planResult.type === "err") {
+      console.error(renderError(planResult.error));
+      return 1;
+    }
+    const plan = planResult.value;
+    console.log(renderPlanReport(plan));
+    if (plan.hasConflicts() && !parsed.force) {
+      if (mode === "interactive") {
+        const proceed = await ports.tty.confirm("Continue past the conflicts listed above?");
+        if (!proceed)
+          return 1;
+      } else {
+        return 1;
+      }
+    }
+    const applied = await Applier.create(ports.applyWrite).apply(plan, inputs.target);
+    if (applied.hasFailures()) {
+      console.error(renderApplyFailure(applied));
+      return 1;
+    }
+    const filesResult = applied.manifestFiles();
+    if (filesResult.type === "err") {
+      console.error(renderError(filesResult.error));
+      return 1;
+    }
+    const manifest = Manifest.build(fetched.value, filesResult.value, {
+      installerPackageVersion: SETUP_VERSION,
+      harness: inputs.harness,
+      installStartedAt: plan.startedAtIso
+    });
+    const written = await ports.manifestIo.write(inputs.target, manifest);
+    if (written.type === "err") {
+      console.error(renderError(written.error));
+      return 1;
+    }
+    const verify = await Verifier.create(ports.verifyRead).verify(inputs.target, manifest);
+    if (!verify.allPassed()) {
+      console.error(renderVerifyFailure(verify));
+      return 1;
+    }
+    console.log(renderSuccess(applied, verify, NextSteps.of(inputs.harness, resolved.value, inputs.target)));
+    return 0;
+  });
+}
+async function runUpgrade(parsed, ports) {
+  const resolvedInputs = await resolveInputs(parsed, ports);
+  if (resolvedInputs.type === "exit")
+    return resolvedInputs.code;
+  const { inputs } = resolvedInputs;
+  const installation = await Installation.detect(inputs.target, ports.manifestIo);
+  const sourceResult = UpgradeSource.fromInstallation(installation, parsed.force);
+  if (sourceResult.type === "err") {
+    console.error(renderError(sourceResult.error));
+    return 1;
+  }
+  const source = sourceResult.value;
+  const resolved = await createResolver(ports.http).resolveVersion(parsed.version);
+  if (resolved.type === "err") {
+    console.error(renderError(resolved.error));
+    return 1;
+  }
+  const assessment = source.assess(resolved.value, parsed.version);
+  if (assessment !== null) {
+    const outcome = assessment.outcome();
+    if (outcome.type !== "proceed") {
+      console.error(renderError(UpgradeRefusal.fromOutcome(outcome)));
+      return outcome.type === "already-up-to-date" ? 0 : 1;
+    }
+  }
+  return withTmpWrite(ports, "amadeus-setup-upgrade-", async (tmpWrite) => {
+    const fetched = await createFetcher(ports.http, tmpWrite).fetchArchive(resolved.value);
+    if (fetched.type === "err") {
+      console.error(renderError(fetched.error));
+      return 1;
+    }
+    const startedAt = new Date().toISOString();
+    const planResult = Plan.forUpgrade(fetched.value, source, inputs.harness, inputs.target, { force: parsed.force, startedAt });
+    if (planResult.type === "err") {
+      console.error(renderError(planResult.error));
+      return 1;
+    }
+    const plan = planResult.value;
+    console.log(renderPlanReport(plan, source.strategyNote()));
+    if (resolvedInputs.mode === "interactive" && !parsed.force) {
+      const proceed = await ports.tty.confirm("Continue with the upgrade plan above?");
+      if (!proceed)
+        return 1;
+    }
+    const applied = await Applier.create(ports.applyWrite).apply(plan, inputs.target);
+    if (applied.hasFailures()) {
+      console.error(renderApplyFailure(applied));
+      return 1;
+    }
+    const filesResult = applied.manifestFiles();
+    if (filesResult.type === "err") {
+      console.error(renderError(filesResult.error));
+      return 1;
+    }
+    const newManifest = source.nextManifest({
+      payload: fetched.value,
+      files: filesResult.value,
+      meta: { installerPackageVersion: SETUP_VERSION, harness: inputs.harness, installStartedAt: plan.startedAtIso }
+    });
+    const written = await ports.manifestIo.write(inputs.target, newManifest);
+    if (written.type === "err") {
+      console.error(renderError(written.error));
+      return 1;
+    }
+    const verify = await Verifier.create(ports.verifyRead).verify(inputs.target, newManifest);
+    if (!verify.allPassed()) {
+      console.error(renderVerifyFailure(verify));
+      return 1;
+    }
+    console.log(renderSuccess(applied, verify, NextSteps.of(inputs.harness, resolved.value, inputs.target)));
+    return 0;
+  });
+}
+var isEntryPoint = process.argv[1] !== undefined && resolve3(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isEntryPoint) {
+  const exitCode = await main(process.argv.slice(2));
+  process.exit(exitCode);
+}
+export {
+  main,
+  createDefaultPorts
+};