@zaip-ai/cli 6.3.0 → 7.6.0

package/templates/.agents/tools/cloud-onboarding-provider.mjs

@@ -0,0 +1,228 @@
+import { isIP } from "node:net";
+import { parseEnv } from "node:util";
+import { selectedPublicKey } from "./cloud-onboarding-credentials.mjs";
+import { fail, fingerprint, hash, inside, text } from "./cloud-onboarding-policy.mjs";
+import { sanitize } from "./cloud-onboarding-ssh.mjs";
+
+export const PROVIDER_CONTRACT = Object.freeze({
+  source: "https://developers.hostinger.com/openapi/openapi.json",
+  version: "1.66.0",
+  verified_at: "2026-10-15",
+  base: "https://developers.hostinger.com/api",
+  host_identity: "unavailable",
+  pagination: "not_declared",
+});
+async function tokenFor(target, ctx) {
+  const source = target.provider?.credential_source;
+  if (!["root", "agents"].includes(source)) fail("provider_credential_source_unavailable");
+  const path = inside(ctx.root, source === "root" ? ".env" : ".agents/.env");
+  await ctx.files.checked(path);
+  const values = parseEnv(await ctx.files.readFile(path, "utf8"));
+  if (!values.HOSTINGER_API_TOKEN) fail("provider_credential_unavailable");
+  return values.HOSTINGER_API_TOKEN;
+}
+async function request(target, ctx, suffix, method = "GET", body) {
+  const token = await tokenFor(target, ctx);
+  try {
+    const response = await ctx.http(PROVIDER_CONTRACT.base + suffix, {
+      method,
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : undefined,
+      redirect: "error",
+      signal: AbortSignal.timeout(15000),
+    });
+    if (response.status === 404 || response.status === 405) fail("provider_capability_unavailable");
+    if (!response.ok)
+      fail(method === "GET" ? "provider_request_failed" : "remote_result_requires_reconciliation");
+    if (response.status === 202) return { pending: true };
+    let bytes;
+    if (response.body && typeof response.body[Symbol.asyncIterator] === "function") {
+      const chunks = [];
+      let total = 0;
+      for await (const chunk of response.body) {
+        total += chunk.length;
+        if (total > 2 * 1024 * 1024) fail("provider_output_limit");
+        chunks.push(Buffer.from(chunk));
+      }
+      bytes = Buffer.concat(chunks).toString("utf8");
+    } else bytes = await response.text();
+    if (Buffer.byteLength(bytes) > 2 * 1024 * 1024) fail("provider_output_limit");
+    return JSON.parse(bytes);
+  } catch (error) {
+    if (method !== "GET") fail("remote_result_requires_reconciliation");
+    if (
+      [
+        "provider_capability_unavailable",
+        "provider_request_failed",
+        "provider_output_limit",
+      ].includes(error.code)
+    )
+      throw error;
+    fail("provider_read_unavailable");
+  }
+}
+function addresses(value) {
+  return Array.isArray(value)
+    ? value
+        .slice(0, 64)
+        .flatMap((v) =>
+          typeof v === "string" ? [v] : typeof v?.address === "string" ? [v.address] : [],
+        )
+        .filter((value) => value.length <= 64 && isIP(value))
+    : [];
+}
+function matches(vm, selector) {
+  if (selector.kind === "id") return String(vm.id) === selector.value;
+  if (selector.kind === "hostname") return vm.hostname === selector.value;
+  return [...addresses(vm.ipv4), ...addresses(vm.ipv6)].includes(selector.value);
+}
+function metadata(vm) {
+  const scalar = (value) =>
+    typeof value === "string" ? sanitize(value, 240) : typeof value === "number" ? value : null;
+  return {
+    id: String(vm.id),
+    state: scalar(vm.state),
+    hostname: scalar(vm.hostname),
+    plan:
+      vm.plan && typeof vm.plan === "object"
+        ? { id: scalar(vm.plan.id), name: scalar(vm.plan.name) }
+        : scalar(vm.plan),
+    data_center_id: scalar(vm.data_center_id),
+    template:
+      vm.template && typeof vm.template === "object"
+        ? { id: scalar(vm.template.id), name: scalar(vm.template.name) }
+        : null,
+    ipv4: addresses(vm.ipv4),
+    ipv6: addresses(vm.ipv6),
+    cpus: scalar(vm.cpus),
+    memory_mb: scalar(vm.memory),
+    disk_mb: scalar(vm.disk),
+    billing: null,
+    backups: null,
+    host_fingerprint: null,
+    unavailable: ["billing", "backups", "host_fingerprint"],
+  };
+}
+export async function discover(target, ctx) {
+  const provider = target.provider;
+  if (provider?.name !== "hostinger" || !provider.account_reference)
+    fail("provider_scope_unavailable");
+  const selector = provider.selector;
+  if (!selector || !["id", "hostname", "ip"].includes(selector.kind))
+    fail("provider_selector_unavailable");
+  text(selector.value);
+  // The current official contract is an array, without pagination parameters or a next URL.
+  const collection = await request(target, ctx, "/vps/v1/virtual-machines");
+  if (!Array.isArray(collection) || collection.length > 1000)
+    fail("provider_collection_schema_unavailable");
+  const found = collection.filter((vm) => vm && vm.id !== undefined && matches(vm, selector));
+  if (found.length !== 1)
+    fail(found.length ? "ambiguous_provider_target" : "provider_target_not_found");
+  const id = String(found[0].id);
+  if (!/^\d+$/.test(id) || (provider.vps_id && provider.vps_id !== id))
+    fail("provider_target_mismatch");
+  const details = await request(target, ctx, `/vps/v1/virtual-machines/${encodeURIComponent(id)}`);
+  if (String(details?.id) !== id || !matches(details, selector)) fail("provider_target_mismatch");
+  if (
+    target.ssh &&
+    ![details.hostname, ...addresses(details.ipv4), ...addresses(details.ipv6)].includes(
+      target.ssh.host,
+    )
+  )
+    fail("provider_ssh_target_mismatch");
+  let region = null;
+  if (details.data_center_id !== null && details.data_center_id !== undefined) {
+    try {
+      const centers = await request(target, ctx, "/vps/v1/data-centers");
+      if (Array.isArray(centers) && centers.length <= 1000) {
+        const match = centers.filter(
+          (center) => String(center?.id) === String(details.data_center_id),
+        );
+        if (match.length === 1) {
+          const center = match[0],
+            clean = (value) => (typeof value === "string" ? sanitize(value, 120) : null);
+          region = {
+            id: String(center.id),
+            name: clean(center.name),
+            country: clean(center.location),
+            city: clean(center.city),
+            continent: clean(center.continent),
+          };
+        }
+      }
+    } catch {
+      /* Optional provider metadata never becomes a prerequisite of SSH. */
+    }
+  }
+  const result = {
+    source: PROVIDER_CONTRACT,
+    observed_at: ctx.now(),
+    account_reference: provider.account_reference,
+    ...metadata(details),
+    region,
+    region_state: region ? "observed" : "unavailable",
+  };
+  const inventory = await ctx.files.receipt(["provider", target.name, result.observed_at], result);
+  return { state: "observed", provider_inventory: inventory, ...result };
+}
+export async function registerPublicKey(target, ctx) {
+  const provider = target.provider;
+  if (target.ssh?.user !== "root") fail("provider_root_login_only");
+  if (
+    provider?.name !== "hostinger" ||
+    !/^\d+$/.test(provider.vps_id ?? "") ||
+    !provider.account_reference ||
+    provider.public_key_registration_authorized !== true
+  )
+    fail("public_key_registration_not_authorized");
+  const identity = await selectedPublicKey(target, ctx);
+  const key = provider.public_key ? text(provider.public_key, 16384) : identity.public_key;
+  if (fingerprint(key) !== identity.public_fingerprint) fail("public_key_identity_mismatch");
+  // Resolve the authorized target again before a write; a broad token never selects another VPS.
+  const observed = await discover(target, ctx);
+  if (observed.id !== provider.vps_id) fail("provider_target_mismatch");
+  const suffix = `/vps/v1/virtual-machines/${encodeURIComponent(provider.vps_id)}/ssh-keys`;
+  const contains = (collection) => {
+    if (!Array.isArray(collection) || collection.length > 1000)
+      fail("provider_collection_schema_unavailable");
+    return collection.some((item) => {
+      try {
+        return (
+          fingerprint(item.key ?? `${item.type} ${item.key_data}`) === identity.public_fingerprint
+        );
+      } catch {
+        return false;
+      }
+    });
+  };
+  if (contains(await request(target, ctx, suffix)))
+    return { state: "verified", idempotent: true, vps_id: provider.vps_id };
+  const attempt = inside(
+    ctx.root,
+    `.agents/private/state/cloud/onboarding/${hash(["public-key-attempt", target.name, provider.vps_id, fingerprint(key)])}.json`,
+  );
+  let pending = false;
+  try {
+    await ctx.files.checked(attempt);
+    pending = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (pending) fail("remote_result_requires_reconciliation");
+  await ctx.files.receipt(["public-key-attempt", target.name, provider.vps_id, fingerprint(key)], {
+    state: "attempted",
+    operation: "public-key-register",
+    target: target.name,
+    observed_at: ctx.now(),
+  });
+  // On error or a 202, observe before any possible retry. No automatic second POST.
+  let writeError;
+  try {
+    await request(target, ctx, suffix, "POST", { keys: [key] });
+  } catch (error) {
+    writeError = error;
+  }
+  if (!contains(await request(target, ctx, suffix)))
+    fail(writeError?.code ?? "remote_result_requires_reconciliation");
+  return { state: "verified", vps_id: provider.vps_id, public_fingerprint: fingerprint(key) };
+}

package/templates/.agents/tools/cloud-onboarding-provider.test.mjs

@@ -0,0 +1,144 @@
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+import test from "node:test";
+import { discover, registerPublicKey } from "./cloud-onboarding-provider.mjs";
+
+import { fixture, root, userKey } from "./cloud-onboarding-test-fixture.mjs";
+
+function providerFixture() {
+  const f = fixture();
+  f.target.provider = {
+    name: "hostinger",
+    account_reference: "fictional-account",
+    credential_source: "root",
+    selector: { kind: "hostname", value: "123" },
+    vps_id: "101",
+  };
+  const vm = {
+    id: 101,
+    hostname: "123",
+    state: "running",
+    ipv4: [{ address: "192.0.2.10" }],
+    plan: null,
+    data_center_id: null,
+    template: null,
+  };
+  f.data.set(
+    resolve(root, ".env"),
+    "HOSTINGER_API_TOKEN=fictional-provider-value\nUNRELATED_SECRET=not-forwarded\n",
+  );
+  const requests = [];
+  f.ctx.http = async (url, options) => {
+    requests.push([url, options]);
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify(url.endsWith("/virtual-machines") ? [vm] : vm),
+    };
+  };
+  return { ...f, vm, requests };
+}
+test("VPS-12,13 provider matches actual ID, exact hostname/IP and preserves missing metadata", async () => {
+  const f = providerFixture();
+  const result = await discover(f.target, f.ctx);
+  assert.equal(result.id, "101");
+  assert.equal(result.plan, null);
+  assert.equal(result.host_fingerprint, null);
+  assert.ok(
+    f.requests[1][0].endsWith("/virtual-machines/101"),
+    "numeric hostname must not become the ID",
+  );
+  assert.equal(f.requests[0][1].headers.Authorization, "Bearer fictional-provider-value");
+  assert.ok(!JSON.stringify(f.requests[0][1]).includes("UNRELATED_SECRET"));
+  f.target.provider.selector = { kind: "ip", value: "192.0.2.10" };
+  assert.equal((await discover(f.target, f.ctx)).id, "101");
+});
+test("VPS-12,13 no invented pagination, out-of-scope ID or ambiguous discovery", async () => {
+  for (const body of [
+    [
+      { id: 101, hostname: "123" },
+      { id: 102, hostname: "123" },
+    ],
+    [],
+    { data: [], next_page_url: "https://other.invalid" },
+  ]) {
+    const f = providerFixture();
+    f.ctx.http = async () => ({ ok: true, status: 200, text: async () => JSON.stringify(body) });
+    await assert.rejects(
+      discover(f.target, f.ctx),
+      /ambiguous_provider_target|provider_target_not_found|provider_collection_schema_unavailable/,
+    );
+  }
+  const f = providerFixture();
+  f.target.provider.vps_id = "102";
+  await assert.rejects(discover(f.target, f.ctx), /provider_target_mismatch/);
+});
+test("VPS-12,13 region is resolved from the verified data-center ID or remains unavailable", async () => {
+  const f = providerFixture();
+  f.vm.data_center_id = 7;
+  const previous = f.ctx.http;
+  f.ctx.http = async (...args) =>
+    args[0].endsWith("/data-centers")
+      ? {
+          ok: true,
+          status: 200,
+          text: async () =>
+            JSON.stringify([
+              {
+                id: 7,
+                name: "fictional-region",
+                location: "BR",
+                city: "Fictional city",
+                continent: "SA",
+              },
+            ]),
+        }
+      : previous(...args);
+  assert.equal((await discover(f.target, f.ctx)).region.country, "BR");
+  f.ctx.http = async (...args) =>
+    args[0].endsWith("/data-centers") ? { ok: false, status: 403 } : previous(...args);
+  const result = await discover(f.target, f.ctx);
+  assert.equal(result.id, "101");
+  assert.equal(result.region, null);
+  assert.equal(result.region_state, "unavailable");
+});
+test("VPS-22,36 public-key response loss is reconciled by GET without a second write", async () => {
+  const f = providerFixture();
+  f.target.ssh.user = "root";
+  Object.assign(f.target.provider, {
+    public_key_registration_authorized: true,
+    public_key: userKey,
+  });
+  let stored = false,
+    posts = 0;
+  f.ctx.http = async (url, options) => {
+    if (url.endsWith("/ssh-keys")) {
+      if (options.method === "POST") {
+        posts++;
+        stored = true;
+        throw Error("response lost");
+      }
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify(stored ? [{ key: userKey }] : []),
+      };
+    }
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify(url.endsWith("/virtual-machines") ? [f.vm] : f.vm),
+    };
+  };
+  assert.equal((await registerPublicKey(f.target, f.ctx)).state, "verified");
+  assert.equal((await registerPublicKey(f.target, f.ctx)).idempotent, true);
+  assert.equal(posts, 1);
+  f.target.ssh.user = "operator";
+  await assert.rejects(registerPublicKey(f.target, f.ctx), /provider_root_login_only/);
+});
+test("VPS-34 existing hosts are only observed; no creation/reinstall/configuration operation exists", async () => {
+  const f = fixture();
+  for (const op of ["vps:create", "vps:reinstall", "vps:ssh:configure", "vps:delete"])
+    await assert.rejects(f.invoke(op), /operation_not_allowed/);
+  assert.equal(f.calls.length, 0);
+});

package/templates/.agents/tools/cloud-onboarding-recovery.test.mjs

@@ -0,0 +1,306 @@
+import assert from "node:assert/strict";
+import { resolve } from "node:path";
+import test from "node:test";
+import { runOnboarding } from "./cloud-onboarding.mjs";
+import { ARCHITECTURE_SECTIONS, recordArchitecture } from "./cloud-onboarding-architecture.mjs";
+import { CONTRACT, hash, REQUEST } from "./cloud-onboarding-policy.mjs";
+import { PROBES } from "./cloud-onboarding-ssh.mjs";
+
+import { fixture, root, userKey } from "./cloud-onboarding-test-fixture.mjs";
+
+function architecture() {
+  return {
+    id: "one-host-confirmed",
+    kind: "confirmed",
+    origin: "human",
+    authorization_reference: "human-confirmation-fixture",
+    reason: null,
+    hosts: [{ name: "primary", responsibilities: "API, workers and private persistence" }],
+    sections: Object.fromEntries(
+      Object.keys(ARCHITECTURE_SECTIONS).map((k) => [
+        k,
+        `Chosen ${k} remains private and subject to verification.`,
+      ]),
+    ),
+  };
+}
+test("VPS-02,04,05,07,08,09 architecture retains one principal, history, scope and four distinct states", async () => {
+  const f = fixture(),
+    decision = architecture();
+  const path = resolve(root, ".agents/architecture/software-architecture.md");
+  const previous =
+    "# Existing architecture\n\n## Unaffected business module\n\nKeep this unchanged.\n";
+  decision.document = previous;
+  f.data.set(path, previous);
+  decision.previous_sha256 = hash(previous);
+  f.data.set(resolve(root, "infra/main.tf"), "two-hosts-fixture");
+  decision.implementation = {
+    path: "infra/main.tf",
+    sha256: hash("two-hosts-fixture"),
+    host_count: 2,
+  };
+  const result = await recordArchitecture(decision, f.ctx);
+  assert.equal(result.implementation.divergence, "terraform_adaptation_pending");
+  assert.equal(result.deployed.state, "unverified");
+  assert.equal(result.grants_remote_authority, false);
+  assert.match(f.data.get(path), /Keep this unchanged/);
+  assert.match(f.data.get(path), /flowchart TD/);
+  for (const heading of Object.values(ARCHITECTURE_SECTIONS))
+    assert.ok(f.data.get(path).includes(heading));
+  const journal = JSON.parse(f.data.get(resolve(root, result.decision)));
+  assert.equal(journal.reason, null);
+  assert.equal(journal.origin, "human");
+  assert.ok(f.data.get(resolve(root, journal.previous)).includes(previous));
+  assert.equal((await recordArchitecture(decision, f.ctx)).idempotent, true);
+});
+test("VPS-06 exploratory language never becomes a human decision", async () => {
+  const f = fixture(),
+    decision = architecture();
+  decision.kind = "exploration";
+  assert.equal((await recordArchitecture(decision, f.ctx)).state, "unchanged");
+  assert.ok(!f.data.has(resolve(root, ".agents/architecture/software-architecture.md")));
+  decision.kind = "technical";
+  await assert.rejects(recordArchitecture(decision, f.ctx), /decision_origin_unavailable/);
+  decision.origin = "agent";
+  decision.deployed = true;
+  await assert.rejects(
+    recordArchitecture(decision, f.ctx),
+    /deployment_requires_observed_evidence/,
+  );
+});
+test("VPS-23 architecture implementation cannot read a secret path for hashing", async () => {
+  const f = fixture(),
+    decision = architecture();
+  const secretPath = resolve(root, ".env");
+  f.data.set(secretPath, "fictional-sensitive-value");
+  decision.implementation = {
+    path: ".env",
+    sha256: hash("fictional-sensitive-value"),
+    host_count: 1,
+  };
+  await assert.rejects(recordArchitecture(decision, f.ctx), /implementation_source_path_denied/);
+  assert.ok(!f.reads.includes(secretPath));
+});
+test("VPS-10,36,37 architecture detects concurrent writes and pending replacement can resume", async () => {
+  const f = fixture(),
+    decision = architecture();
+  decision.document = "# Coherent revised architecture\n";
+  const path = resolve(root, ".agents/architecture/software-architecture.md");
+  f.data.set(path, "original");
+  decision.previous_sha256 = hash("original");
+  const rename = f.files.rename;
+  let failOnce = true;
+  f.files.rename = async (...args) => {
+    if (failOnce) {
+      failOnce = false;
+      throw Object.assign(Error("interrupted"), { code: "EIO" });
+    }
+    return rename(...args);
+  };
+  await assert.rejects(recordArchitecture(decision, f.ctx), /interrupted/);
+  assert.equal(f.data.get(path), "original");
+  await recordArchitecture(decision, f.ctx);
+  decision.id = "other-decision";
+  await assert.rejects(
+    recordArchitecture(decision, f.ctx),
+    /architecture_changed_requires_reconciliation/,
+  );
+});
+test("VPS-01,23 contract rejects private material and secret fields before persistence", async () => {
+  const f = fixture();
+  f.target.credential.passphrase = "fictional-sensitive-value";
+  f.data.set(
+    resolve(root, REQUEST),
+    JSON.stringify({ version: 1, authorization: f.contract.authorization, targets: [f.target] }),
+  );
+  await assert.rejects(
+    runOnboarding({ operation: "vps:prepare", request: REQUEST }, f.ctx),
+    /secret_material_denied/,
+  );
+});
+test("VPS-14,26,33,36 local preparation evolves with discovered public trust using exact prior hash", async () => {
+  const f = fixture(),
+    ssh = structuredClone(f.target.ssh);
+  delete f.target.ssh;
+  f.data.delete(resolve(root, CONTRACT));
+  const putRequest = (previous) =>
+    f.data.set(
+      resolve(root, REQUEST),
+      JSON.stringify({
+        version: 1,
+        authorization: f.contract.authorization,
+        targets: [f.target],
+        ...(previous ? { expected_previous_hash: previous } : {}),
+      }),
+    );
+  putRequest();
+  const first = await runOnboarding({ operation: "vps:prepare", request: REQUEST }, f.ctx);
+  Object.assign(f.target, JSON.parse(f.data.get(resolve(root, CONTRACT))).targets[0]);
+  await f.invoke("vps:credential:prepare");
+  f.target.ssh = ssh;
+  putRequest();
+  await assert.rejects(
+    runOnboarding({ operation: "vps:prepare", request: REQUEST }, f.ctx),
+    /contract_revision_requires_expected_hash/,
+  );
+  putRequest(first.contract_sha256);
+  const second = await runOnboarding({ operation: "vps:prepare", request: REQUEST }, f.ctx);
+  Object.assign(f.target, JSON.parse(f.data.get(resolve(root, CONTRACT))).targets[0]);
+  assert.notEqual(first.bindings.primary, second.bindings.primary);
+  await f.invoke("vps:ssh:trust");
+  await f.invoke("vps:ssh:test");
+  assert.equal(
+    (await runOnboarding({ operation: "vps:prepare", request: REQUEST }, f.ctx)).contract_sha256,
+    second.contract_sha256,
+  );
+});
+test("VPS-19,20 protected interactive generation cannot silently accept an unprotected result; broad external ACL denies", async () => {
+  const f = fixture();
+  f.target.credential = { name: "new-key", mode: "generate" };
+  f.save();
+  f.ctx.interactiveKeygen = async (path) => {
+    f.data.set(path, "newly-created-unprotected-fixture");
+    f.data.set(`${path}.pub`, userKey);
+    return { code: 0 };
+  };
+  const exec = f.ctx.exec;
+  f.ctx.exec = async (...args) =>
+    args[0] === "ssh-keygen" && args[1].includes("-y")
+      ? { code: 0, stdout: userKey }
+      : exec(...args);
+  await assert.rejects(f.invoke("vps:credential:prepare"), /unprotected_key_acceptance_required/);
+  const g = fixture();
+  g.files.verifyPermissions = async () => {
+    throw Object.assign(Error("credential_permissions_too_broad"), {
+      code: "credential_permissions_too_broad",
+    });
+  };
+  await assert.rejects(g.invoke("vps:credential:prepare"), /credential_permissions_too_broad/);
+  assert.ok(!g.calls.some((c) => c[0] === "ssh"));
+});
+test("VPS-19,20 generation preserves existing public destination and denies linked public destination before keygen", async () => {
+  for (const linked of [false, true]) {
+    const f = fixture();
+    f.target.credential = {
+      name: "public-conflict",
+      mode: "generate",
+      unprotected: true,
+      unprotected_acceptance: true,
+    };
+    f.save();
+    const publicPath = resolve(root, ".agents/private/state/ssh/public-conflict/identity.pub");
+    f.data.set(publicPath, "existing-public-bytes");
+    if (linked) {
+      const checked = f.files.checked;
+      f.files.checked = async (...args) => {
+        if (args[0] === publicPath)
+          throw Object.assign(Error("linked_path_denied"), { code: "linked_path_denied" });
+        return checked(...args);
+      };
+    }
+    await assert.rejects(
+      f.invoke("vps:credential:prepare"),
+      linked ? /linked_path_denied/ : /generation_destination_exists/,
+    );
+    assert.equal(f.data.get(publicPath), "existing-public-bytes");
+    assert.ok(!f.calls.some((c) => c[0] === "ssh-keygen" && c[1].includes("-t")));
+  }
+});
+test("VPS-28 independent failed OS probe is unavailable even when architecture succeeds", async () => {
+  const f = fixture();
+  await f.invoke("vps:ssh:trust");
+  const exec = f.ctx.exec;
+  f.ctx.exec = async (...args) =>
+    args[0] === "ssh"
+      ? {
+          code: 0,
+          stdout:
+            "\nZAIP_BEGIN_os\n\nZAIP_END_os_2\n\nZAIP_BEGIN_architecture\nfixture-machine\nZAIP_END_architecture_0\n\nZAIP_BEGIN_docker\nfixture-engine\nZAIP_END_docker_0\n\nZAIP_BEGIN_compose\n\nZAIP_END_compose_127\n",
+        }
+      : exec(...args);
+  const result = await f.invoke("vps:ssh:inventory");
+  assert.equal(result.fields.os.state, "unavailable");
+  assert.equal(result.fields.architecture.state, "observed");
+  assert.equal(result.fields.docker.state, "observed");
+  assert.equal(result.fields.compose.state, "unavailable");
+  assert.ok(!PROBES.os.includes("uname"));
+  assert.ok(!PROBES.docker.includes("compose"));
+});
+test("VPS-02,07 architecture selects an existing alternate principal and preserves observations", async () => {
+  const f = fixture(),
+    decision = architecture();
+  const alternate = resolve(root, ".agents/architecture/deployment.md");
+  f.data.set(alternate, "old alternate");
+  decision.previous_sha256 = hash("old alternate");
+  decision.document = "# Revised existing principal\n";
+  await f.invoke("vps:ssh:trust");
+  const inventory = await f.invoke("vps:ssh:inventory");
+  const observation = JSON.parse(f.data.get(resolve(root, inventory.inventory)));
+  decision.observations = [{ path: inventory.inventory, sha256: hash(observation) }];
+  const result = await recordArchitecture(decision, f.ctx);
+  assert.equal(result.principal, ".agents/architecture/deployment.md");
+  assert.ok(!f.data.has(resolve(root, ".agents/architecture/software-architecture.md")));
+  const after = f.data.get(alternate);
+  const next = {
+    ...decision,
+    id: "revised-one-host",
+    observations: [],
+    previous_sha256: hash(after),
+  };
+  const second = await recordArchitecture(next, f.ctx);
+  const journal = JSON.parse(f.data.get(resolve(root, second.decision)));
+  assert.equal(journal.operational_observations.length, 1);
+  assert.equal(journal.deployed.state, "inventory_observed");
+});
+test("VPS-33,34,36 host/container configuration requires inventory, dedicated approved scripts and readback before retry", async () => {
+  const f = fixture();
+  f.target.allowed_operations.push("vps:host:configure", "vps:containers:configure");
+  f.save();
+  await f.invoke("vps:ssh:trust");
+  const inventory = await f.invoke("vps:ssh:inventory");
+  const body = JSON.parse(f.data.get(resolve(root, inventory.inventory)));
+  const script = "printf 'apply fictional host settings'\n",
+    readback = "printf 'read fictional host settings'\n";
+  f.data.set(resolve(root, ".agents/config/vps-scripts/host.sh"), script);
+  f.data.set(resolve(root, ".agents/config/vps-scripts/check.sh"), readback);
+  const config = {
+    authorization_reference: "authorized-script-fixture",
+    previous_access_preserved: true,
+    inventory: inventory.inventory,
+    inventory_sha256: hash(body),
+    script_path: ".agents/config/vps-scripts/host.sh",
+    script_sha256: hash(script),
+    readback_script_path: ".agents/config/vps-scripts/check.sh",
+    readback_sha256: hash(readback),
+    expected_marker: "ZAIP_HOST_READY",
+  };
+  f.target.configuration = { host: config, containers: config };
+  f.save();
+  const previous = f.ctx.exec;
+  let applied = false,
+    effects = 0;
+  f.ctx.exec = async (...args) => {
+    if (args[0] === "ssh") {
+      if (args[2].input === script) {
+        effects++;
+        applied = true;
+        return { code: 1, timedOut: true };
+      }
+      if (args[2].input === readback)
+        return { code: applied ? 0 : 1, stdout: applied ? config.expected_marker : "" };
+    }
+    return previous(...args);
+  };
+  assert.equal((await f.invoke("vps:host:configure")).state, "verified");
+  assert.equal((await f.invoke("vps:host:configure")).idempotent, true);
+  assert.equal(effects, 1);
+  config.script_path = ".env";
+  f.save();
+  await assert.rejects(f.invoke("vps:host:configure"), /configuration_script_path_denied/);
+  config.script_path = ".agents/config/vps-scripts/host.sh";
+  body.fields.firewall.state = "unavailable";
+  f.data.set(resolve(root, inventory.inventory), JSON.stringify(body));
+  config.inventory_sha256 = hash(body);
+  f.save();
+  await assert.rejects(f.invoke("vps:containers:configure"), /configuration_inventory_incomplete/);
+});