@zaip-ai/cli 6.3.0 → 7.5.0

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/lead-measurement.test.mjs

@@ -0,0 +1,288 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { queueMeasurement, recordDeliveryAttempt } from "./delivery-ledger.mjs";
+import * as deliveryV2 from "./delivery-v2.mjs";
+import { deliveryV2Cases } from "./delivery-v2-cases.mjs";
+import * as contractV2 from "./delivery-v2-contract.mjs";
+import { projectMeasurement, validateConfig, validateEnvelope } from "./lead-measurement.mjs";
+
+// First 25 cases preserve the LEGACY DEPRECATED v1 baseline, not operational proof.
+
+const eventPath = new URL("../references/synthetic-event.json", import.meta.url);
+const configPath = new URL("../references/synthetic-config.json", import.meta.url);
+const exampleEvent = JSON.parse(await readFile(eventPath, "utf8"));
+const exampleConfig = JSON.parse(await readFile(configPath, "utf8"));
+const fixture = () => ({
+  event: structuredClone(exampleEvent),
+  config: structuredClone(exampleConfig),
+});
+
+test("projects only allowlisted enums after backend acceptance, with one Ads primary and matching Meta identity", () => {
+  const { event, config } = fixture();
+  const output = projectMeasurement(event, config);
+  assert.equal(output.ga4.event_name, "generate_lead");
+  assert.equal(output.google_ads.source, "ga4_import");
+  assert.equal(output.google_ads.primary, true);
+  assert.deepEqual(output.meta_pixel, output.meta_capi);
+  assert.equal(output.meta_pixel.event_name, "Lead");
+  assert.equal(output.meta_pixel.event_id, event.event_id);
+  assert.equal(output.data_layer.event, "lead_accepted");
+  assert.doesNotMatch(JSON.stringify(output), /receipt|acceptance|persisted|email|phone|form/i);
+  assert.deepEqual(Object.keys(output.ga4.parameters).sort(), [
+    "budget_band",
+    "qualification",
+    "service",
+  ]);
+  assert.equal(event.acceptance.persisted, true);
+});
+
+test("later qualification has a separate mapping and never recreates the primary registration", () => {
+  const { event, config } = fixture();
+  event.event_name = "lead_qualified";
+  event.event_id = "evt_synthetic_qualified";
+  const projected = projectMeasurement(event, config);
+  assert.equal(projected.ga4.event_name, "lead_qualified");
+  assert.equal(projected.meta_pixel.event_name, "QualifiedLead");
+  assert.equal(projected.google_ads, null);
+  config.events.lead_qualified.meta = "Lead";
+  assert.throws(() => projectMeasurement(event, config), /registration_mapping_conflict/);
+});
+
+for (const state of ["denied", "unknown", "missing"])
+  test(`consent ${state} cannot enable a destination`, () => {
+    const { event, config } = fixture();
+    if (state === "missing") delete event.consent;
+    else event.consent = Object.fromEntries(Object.keys(event.consent).map((key) => [key, state]));
+    const normalized = validateEnvelope(event, config);
+    assert.equal(normalized.consent.analytics_storage, state === "missing" ? "unknown" : state);
+    assert.deepEqual(projectMeasurement(event, config), {
+      ga4: null,
+      google_ads: null,
+      meta_pixel: null,
+      meta_capi: null,
+      data_layer: null,
+    });
+    assert.equal(queueMeasurement(new Map(), event, config, "meta_capi").status, "suppressed");
+  });
+
+test("Google consent does not grant Meta and GA4 consent is required for Ads import", () => {
+  const { event, config } = fixture();
+  event.consent.meta_measurement = "denied";
+  assert.equal(projectMeasurement(event, config).meta_pixel, null);
+  assert.notEqual(projectMeasurement(event, config).ga4, null);
+  event.consent.analytics_storage = "denied";
+  assert.equal(projectMeasurement(event, config).google_ads, null);
+  config.google_ads.primary_source = "direct";
+  config.google_ads.sources.direct.primary = true;
+  config.google_ads.sources.ga4_import.primary = false;
+  config.required_consent.google_ads = ["ad_storage", "ad_user_data"];
+  assert.equal(projectMeasurement(event, config).google_ads.source, "direct");
+});
+
+const invalidCases = [
+  [
+    "backend rejection",
+    ({ event }) => {
+      event.acceptance.persisted = false;
+    },
+  ],
+  [
+    "attempt event",
+    ({ event }) => {
+      event.event_name = "form_submit";
+    },
+  ],
+  [
+    "unknown field",
+    ({ event }) => {
+      event.contact = "synthetic@example.invalid";
+    },
+  ],
+  [
+    "contact classification",
+    ({ event }) => {
+      event.classification.email = "synthetic@example.invalid";
+    },
+  ],
+  [
+    "free text enum",
+    ({ event }) => {
+      event.classification.service = "please call a synthetic person";
+    },
+  ],
+  [
+    "unknown enum",
+    ({ event }) => {
+      event.classification.service = "unknown-service";
+    },
+  ],
+  [
+    "invalid date",
+    ({ event }) => {
+      event.occurred_at = "2026-02-30T12:00:00Z";
+    },
+  ],
+  [
+    "invalid timezone",
+    ({ event }) => {
+      event.occurred_at = "2026-10-27T12:00:00+99:00";
+    },
+  ],
+  [
+    "contact event identity",
+    ({ event }) => {
+      event.event_id = "synthetic@example.invalid";
+    },
+  ],
+  [
+    "invalid consent",
+    ({ event }) => {
+      event.consent.analytics_storage = true;
+    },
+  ],
+  [
+    "two primaries",
+    ({ config }) => {
+      config.google_ads.sources.direct.primary = true;
+    },
+  ],
+  [
+    "empty consent contract",
+    ({ config }) => {
+      config.required_consent.meta = [];
+    },
+  ],
+  [
+    "unbounded retries",
+    ({ config }) => {
+      config.retry.max_attempts = Infinity;
+    },
+  ],
+];
+for (const [label, mutate] of invalidCases)
+  test(`rejects ${label}`, () => {
+    const values = fixture();
+    mutate(values);
+    assert.throws(() => projectMeasurement(values.event, values.config));
+  });
+
+test("valid RFC3339 offsets and absent individual consent normalize without mutating input", () => {
+  const { event, config } = fixture();
+  event.occurred_at = "2026-10-27T12:00:00-03:00";
+  delete event.consent.ad_personalization;
+  assert.equal(validateEnvelope(event, config).consent.ad_personalization, "unknown");
+  assert.equal(Object.hasOwn(event.consent, "ad_personalization"), false);
+  assert.equal(validateConfig(config).mapping_version, "synthetic-v1");
+});
+
+test("destination/event identity replays and conflicting payload or mapping never overwrites the job", () => {
+  const { event, config } = fixture();
+  const first = queueMeasurement(new Map(), event, config, "meta_capi");
+  const replay = queueMeasurement(first.ledger, event, config, "meta_capi");
+  assert.equal(first.status, "queued");
+  assert.equal(replay.status, "replay");
+  assert.equal(first.ledger.size, 1);
+  assert.deepEqual(replay.job, first.job);
+  const other = queueMeasurement(first.ledger, event, config, "ga4");
+  assert.equal(other.ledger.size, 2);
+  assert.equal(first.ledger.size, 1);
+  event.classification.service = "painting";
+  assert.throws(() => queueMeasurement(first.ledger, event, config, "meta_capi"), /conflict/);
+  event.classification.service = "renovation";
+  config.mapping_version = "synthetic-v2";
+  assert.throws(() => queueMeasurement(first.ledger, event, config, "meta_capi"), /conflict/);
+  assert.equal(first.job.payload.parameters.service, "renovation");
+});
+
+test("ledger key cannot relabel a valid job from another destination", () => {
+  const { event, config } = fixture();
+  const pixel = queueMeasurement(new Map(), event, config, "meta_pixel").job;
+  const ledger = new Map([[`meta_capi:${event.event_id}`, pixel]]);
+  assert.throws(
+    () => queueMeasurement(ledger, event, config, "meta_capi"),
+    /delivery_key_identity_conflict/,
+  );
+  assert.equal(ledger.get(`meta_capi:${event.event_id}`).destination, "meta_pixel");
+});
+
+test("bounded retry respects retry-after, freezes occurrence/name/id/payload and preserves accepted lead", () => {
+  const { event, config } = fixture();
+  const initial = queueMeasurement(new Map(), event, config, "meta_capi").job;
+  const retry = recordDeliveryAttempt(
+    initial,
+    { status: 429, retry_after_ms: 120000 },
+    "2026-10-27T19:00:01Z",
+  );
+  assert.equal(retry.next_attempt_at, "2026-10-27T19:02:01.000Z");
+  assert.equal(retry.state, "retry");
+  assert.equal(retry.attempts, 1);
+  assert.throws(
+    () => recordDeliveryAttempt(retry, { status: 200 }, "2026-10-27T19:01:00Z"),
+    /retry_not_due/,
+  );
+  const next = recordDeliveryAttempt(retry, { error: "timeout" }, retry.next_attempt_at);
+  const exhausted = recordDeliveryAttempt(next, { status: 503 }, next.next_attempt_at);
+  assert.equal(exhausted.state, "review_required");
+  assert.equal(exhausted.attempts, 3);
+  for (const job of [retry, next, exhausted]) {
+    assert.equal(job.acceptance_persisted, true);
+    assert.equal(job.event_id, event.event_id);
+    assert.equal(job.occurred_at, event.occurred_at);
+    assert.equal(job.event_name, "Lead");
+    assert.deepEqual(job.payload, initial.payload);
+    assert.equal(job.fingerprint, initial.fingerprint);
+  }
+  assert.equal(event.acceptance.persisted, true);
+  assert.deepEqual(
+    recordDeliveryAttempt(exhausted, { status: 503 }, "2026-10-28T19:00:00Z"),
+    exhausted,
+  );
+});
+
+test("LEGACY DEPRECATED: success replays, permanent failure requires review, and revocation suppresses a queued projection", () => {
+  const { event, config } = fixture();
+  const queued = queueMeasurement(new Map(), event, config, "ga4");
+  const sent = recordDeliveryAttempt(queued.job, { status: 204 }, "2026-10-27T19:00:01Z");
+  assert.equal(sent.state, "sent");
+  assert.deepEqual(recordDeliveryAttempt(sent, { status: 200 }, "2026-10-27T19:00:02Z"), sent);
+  assert.equal(
+    recordDeliveryAttempt(queued.job, { status: 400 }, "2026-10-27T19:00:01Z").state,
+    "review_required",
+  );
+  event.consent.analytics_storage = "denied";
+  assert.equal(queueMeasurement(queued.ledger, event, config, "ga4").status, "suppressed");
+  assert.equal(queued.ledger.size, 1);
+});
+
+test("CLI runs shipped synthetic examples without network or payload leakage on rejection", () => {
+  const script = fileURLToPath(new URL("./lead-measurement.mjs", import.meta.url));
+  const args = [
+    script,
+    "validate",
+    "--event",
+    fileURLToPath(eventPath),
+    "--config",
+    fileURLToPath(configPath),
+  ];
+  const valid = spawnSync(process.execPath, args, {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 10000,
+  });
+  assert.equal(valid.status, 0, valid.stderr);
+  assert.deepEqual(JSON.parse(valid.stdout), { valid: true, model_only: true });
+  const invalid = spawnSync(
+    process.execPath,
+    [script, "unknown", "--secret", "must-not-be-logged"],
+    { encoding: "utf8", windowsHide: true, timeout: 10000 },
+  );
+  assert.equal(invalid.status, 1);
+  assert.doesNotMatch(invalid.stderr, /must-not-be-logged/);
+  assert.deepEqual(JSON.parse(invalid.stderr), { error: "unknown_action" });
+});
+
+for (const [name, check] of deliveryV2Cases({ ...deliveryV2, ...contractV2 }))
+  test(`v2 ${name}`, check);

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/questionnaire-ast-cases.mjs

@@ -0,0 +1,127 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { evaluate, validateQuestionnaire } from "./check-questionnaire.mjs";
+import {
+  answer,
+  copy,
+  input,
+  leaf,
+  load,
+  rejectAnswer,
+  rejectDoc,
+} from "./questionnaire-test-support.mjs";
+
+export function registerQuestionnaireAstCases() {
+  test("operators and injected expression/property payloads are rejected, including dead branches", () => {
+    for (const op of ["eval", "sql", "constructor", "gte;process.exit()", "unknown"]) {
+      rejectDoc((d) => {
+        d.policy.expression_ast = { op, question: "budget", value: 10000 };
+      }, /ast_operator/);
+    }
+    rejectDoc((d) => {
+      d.policy.expression_ast = "budget >= 10000";
+    }, /type/);
+    rejectDoc((d) => {
+      d.policy.expression_ast = { ...leaf(), expression: "arbitrary code" };
+    }, /keys/);
+    rejectDoc((d) => {
+      d.policy.expression_ast = {
+        op: "any",
+        args: [leaf(), { op: "eval", question: "budget", value: "bad" }],
+      };
+    }, /ast_operator/);
+    rejectAnswer((i) => {
+      i.answers.constructor = answer("bad");
+    }, /keys/);
+  });
+  test("AST reference and operand types are validated without coercion", () => {
+    for (const node of [
+      { op: "gte", question: "authority", value: 2 },
+      { op: "contains", question: "budget", value: 10000 },
+      { op: "eq", question: "need", value: ["solar"] },
+      { op: "in", question: "budget", value: [10000] },
+      { op: "eq", question: "missing", value: "x" },
+      { op: "gte", question: "budget", value: "10000" },
+      { op: "in", question: "authority", value: ["unapproved"] },
+      { op: "contains", question: "need", value: "bad" },
+    ])
+      rejectDoc((d) => {
+        d.policy.expression_ast = node;
+      }, /ast_/);
+  });
+  test("all/any/not evaluate known booleans and preserve uncertainty over short circuits", () => {
+    const d = load("solar"),
+      i = input(d.cases[0]);
+    const no = { op: "eq", question: "authority", value: "researcher" };
+    d.policy.expression_ast = { op: "any", args: [leaf(), no] };
+    assert.equal(evaluate(d, i).outcome, "qualified");
+    d.policy.expression_ast = { op: "not", args: [leaf()] };
+    assert.equal(evaluate(d, i).outcome, "not_qualified");
+    d.questions[1].required = false;
+    i.answers.authority = { state: "unknown", value: null };
+    for (const op of ["all", "any"]) {
+      d.policy.expression_ast = { op, args: [leaf(), no] };
+      assert.equal(evaluate(d, i).outcome, "pending");
+    }
+  });
+  test("AST depth at six passes and seven fails; logical arity is bounded", () => {
+    const d = load("solar");
+    let node = leaf();
+    for (let i = 0; i < 5; i++) node = { op: "not", args: [node] };
+    d.policy.expression_ast = node;
+    assert.equal(validateQuestionnaire(d), true);
+    d.policy.expression_ast = { op: "not", args: [node] };
+    assert.throws(() => validateQuestionnaire(d), /ast_limit/);
+    for (const args of [[], Array.from({ length: 9 }, leaf)])
+      rejectDoc((d) => {
+        d.policy.expression_ast = { op: "all", args };
+      }, /ast_arity/);
+    rejectDoc((d) => {
+      d.policy.expression_ast = { op: "not", args: [leaf(), leaf()] };
+    }, /ast_arity/);
+  });
+  test("AST nodes exactly 64 pass and 65 fail independently of depth/arity", () => {
+    const d = load("solar");
+    const groups = Array.from({ length: 8 }, (_, i) => ({
+      op: "all",
+      args: Array.from({ length: i === 7 ? 6 : 7 }, leaf),
+    }));
+    d.policy.expression_ast = { op: "all", args: groups };
+    assert.equal(validateQuestionnaire(d), true);
+    groups[7].args.push(leaf());
+    assert.throws(() => validateQuestionnaire(d), /ast_limit/);
+  });
+  test("question/branch count, enum, label and text bounds are enforced", () => {
+    const d = load("solar");
+    while (d.questions.length < 20)
+      d.questions.push({
+        code: `extra_${d.questions.length}`,
+        dimension: "extension",
+        label: "Extra sintético",
+        type: "text",
+        required: false,
+        max_length: 3,
+        required_when: leaf(),
+      });
+    assert.equal(validateQuestionnaire(d), true);
+    const i = input(d.cases[0]);
+    i.answers.extra_5 = answer("abc");
+    assert.equal(evaluate(d, i).outcome, "qualified");
+    i.answers.extra_5 = answer("abcd");
+    assert.throws(() => evaluate(d, i), /answer_type/);
+    d.questions.push(copy(d.questions[19]));
+    assert.throws(() => validateQuestionnaire(d), /maxItems/);
+    rejectDoc((d) => {
+      d.questions[0].label = "a".repeat(201);
+    }, /maxLength/);
+    rejectDoc((d) => {
+      d.questions[1].options = Array.from({ length: 31 }, (_, i) => ({
+        code: `c${i}`,
+        label: "x",
+      }));
+    }, /maxItems/);
+    rejectDoc((d) => {
+      d.questions[1].options[1].code = "sole";
+    }, /option_code/);
+  });
+}

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/questionnaire-test-support.mjs

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { evaluate, validateQuestionnaire } from "./check-questionnaire.mjs";
+
+export const load = (name) =>
+  JSON.parse(readFileSync(new URL(`../references/examples/${name}.json`, import.meta.url), "utf8"));
+export const copy = structuredClone;
+export const input = (c) =>
+  Object.fromEntries(
+    Object.entries(copy(c)).filter(([k]) => !["id", "kind", "expected"].includes(k)),
+  );
+export const answer = (value) => ({ state: "answered", value });
+export const leaf = () => ({ op: "gte", question: "budget", value: 10000 });
+export const run = (doc, c = doc.cases[0]) => evaluate(doc, input(c));
+export const rejectDoc = (mutate, pattern) => {
+  const d = load("solar");
+  mutate(d);
+  assert.throws(() => validateQuestionnaire(d), pattern);
+};
+export const rejectAnswer = (mutate, pattern) => {
+  const d = load("solar");
+  const i = input(d.cases[0]);
+  mutate(i);
+  assert.throws(() => evaluate(d, i), pattern);
+};

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/questionnaire-validation.mjs

@@ -0,0 +1,155 @@
+import { readFileSync } from "node:fs";
+
+export const LIMITS = Object.freeze({ depth: 6, nodes: 64, branches: 20, children: 8 });
+const schemaURL = new URL("../references/questionnaire-v2.schema.json", import.meta.url);
+export const schema = JSON.parse(readFileSync(schemaURL, "utf8"));
+export const own = (o, k) => Object.hasOwn(o, k);
+export const object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+export const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function fail(code, path) {
+  throw new Error(`${code}: ${path}`);
+}
+export function requireThat(ok, code, path) {
+  if (!ok) fail(code, path);
+}
+export function keys(o, allowed, path) {
+  requireThat(object(o) && Object.keys(o).every((k) => allowed.includes(k)), "keys", path);
+}
+export const safeCode = (v) =>
+  typeof v === "string" &&
+  /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(v) &&
+  !["constructor", "prototype", "__proto__"].includes(v);
+export const validDate = (v) =>
+  typeof v === "string" &&
+  /^\d{4}-\d{2}-\d{2}$/.test(v) &&
+  Number.isFinite(Date.parse(`${v}T00:00:00Z`)) &&
+  new Date(`${v}T00:00:00Z`).toISOString().slice(0, 10) === v;
+
+// Deliberately bounded JSON Schema subset; an unsupported keyword fails the CLI.
+export function checkSchema(s = schema) {
+  keys(
+    s,
+    [
+      "$schema",
+      "title",
+      "type",
+      "additionalProperties",
+      "required",
+      "properties",
+      "const",
+      "enum",
+      "minimum",
+      "maximum",
+      "minItems",
+      "maxItems",
+      "maxLength",
+      "items",
+    ],
+    "schema",
+  );
+  if (s.type)
+    requireThat(
+      ["object", "array", "string", "integer", "number", "boolean"].includes(s.type),
+      "schema_type",
+      s.type,
+    );
+  if (s.required)
+    requireThat(
+      Array.isArray(s.required) && s.required.every((k) => own(s.properties ?? {}, k)),
+      "schema_required",
+      "schema",
+    );
+  for (const child of Object.values(s.properties ?? {})) checkSchema(child);
+  if (s.items) checkSchema(s.items);
+  return true;
+}
+export function shape(v, s, path = "$") {
+  if (own(s, "const")) requireThat(equal(v, s.const), "const", path);
+  if (s.enum)
+    requireThat(
+      s.enum.some((x) => equal(v, x)),
+      "enum",
+      path,
+    );
+  const types = {
+    object,
+    array: Array.isArray,
+    string: (x) => typeof x === "string" && x.trim().length > 0,
+    integer: Number.isSafeInteger,
+    number: (x) => typeof x === "number" && Number.isFinite(x),
+    boolean: (x) => typeof x === "boolean",
+  };
+  if (s.type) requireThat(types[s.type](v), "type", path);
+  if (typeof v === "number") {
+    if (own(s, "minimum")) requireThat(v >= s.minimum, "minimum", path);
+    if (own(s, "maximum")) requireThat(v <= s.maximum, "maximum", path);
+  }
+  if (typeof v === "string" && s.maxLength) requireThat(v.length <= s.maxLength, "maxLength", path);
+  if (Array.isArray(v)) {
+    if (s.minItems) requireThat(v.length >= s.minItems, "minItems", path);
+    if (s.maxItems) requireThat(v.length <= s.maxItems, "maxItems", path);
+    if (s.items)
+      v.forEach((x, i) => {
+        shape(x, s.items, `${path}[${i}]`);
+      });
+  }
+  if (object(v)) {
+    for (const k of s.required ?? []) requireThat(own(v, k), "required", `${path}.${k}`);
+    if (s.additionalProperties === false) keys(v, Object.keys(s.properties ?? {}), path);
+    for (const [k, child] of Object.entries(s.properties ?? {}))
+      if (own(v, k)) shape(v[k], child, `${path}.${k}`);
+  }
+}
+export function scalar(q, v) {
+  if (q.type === "number")
+    return typeof v === "number" && Number.isFinite(v) && v >= q.minimum && v <= q.maximum;
+  if (q.type === "single_choice")
+    return typeof v === "string" && q.options.some((o) => o.code === v);
+  if (q.type === "date") return validDate(v);
+  if (q.type === "text")
+    return typeof v === "string" && v.trim().length > 0 && v.length <= q.max_length;
+  return false;
+}
+export function ast(node, questions, budget = { nodes: 0 }, depth = 1) {
+  requireThat(depth <= LIMITS.depth && ++budget.nodes <= LIMITS.nodes, "ast_limit", "depth/nodes");
+  requireThat(object(node), "ast_object", "node");
+  if (["all", "any", "not"].includes(node.op)) {
+    keys(node, ["op", "args"], "logical_node");
+    requireThat(
+      Array.isArray(node.args) &&
+        node.args.length >= 1 &&
+        node.args.length <= LIMITS.children &&
+        (node.op !== "not" || node.args.length === 1),
+      "ast_arity",
+      node.op,
+    );
+    node.args.forEach((n) => {
+      ast(n, questions, budget, depth + 1);
+    });
+    return;
+  }
+  keys(node, ["op", "question", "value"], "leaf");
+  requireThat(["eq", "in", "contains", "gte", "lte"].includes(node.op), "ast_operator", node.op);
+  const q = questions.find((x) => x.code === node.question);
+  requireThat(q && own(node, "value"), "ast_reference", node.question);
+  if (["gte", "lte"].includes(node.op))
+    requireThat(q.type === "number" && scalar(q, node.value), "ast_number", q.code);
+  if (node.op === "eq") requireThat(scalar(q, node.value), "ast_scalar", q.code);
+  if (node.op === "in")
+    requireThat(
+      q.type === "single_choice" &&
+        Array.isArray(node.value) &&
+        node.value.length > 0 &&
+        node.value.length <= 30 &&
+        new Set(node.value).size === node.value.length &&
+        node.value.every((v) => scalar(q, v)),
+      "ast_in",
+      q.code,
+    );
+  if (node.op === "contains")
+    requireThat(
+      q.type === "multi_choice" && q.options.some((o) => o.code === node.value),
+      "ast_contains",
+      q.code,
+    );
+}

package/templates/.agents/skills/zaip-skill-lifecycle-closure/SKILL.md

@@ -5,6 +5,13 @@ description: Diagnose and safely reconcile ZAIP delivery closure when a Task, Ch
 
 # Close ZAIP lifecycle safely
 
+For an incorrectly captured, still-open childless conversation, apply
+[same-turn promotion](../zaip-skill-execution/references/conversation-promotion.md).
+It settles only that empty interaction and retains delivery/finalization gates.
+Do not manufacture a new human turn or reopen terminal work. Version conflicts
+must be resolved through publication and canonical cycle closure, never by
+retargeting an active Task or resetting recovery counters.
+
 Use for a named Task, Change, Execution, or Run that failed to converge. Start from
 the supplied ID and canonical record; never scan ordinary history to guess a target.
 
@@ -43,8 +50,15 @@ the supplied ID and canonical record; never scan ordinary history to guess a tar
    send it an unfinished framework lock, failed local check, or outdated SHA evidence.
    Rebind validation and independent review after each candidate-changing commit.
 10. For a confirmed residual Git `index.lock`, use the official `git-lock recover --task TASK
-    --run RUN --decision DEC-HUMAN-ID --json` command before claiming a Task workspace.
-    The Decision must explicitly authorize this lock recovery. The command verifies the real
+    --run RUN [--decision DEC-HUMAN-ID] --json` command before claiming a Task workspace.
+    A declared `zaip-aios-full-access` filesystem profile from canonical configuration and an
+    authenticated native principal authorize this narrow procedure without a separate Decision.
+    The CLI requires its exact one-use native hook receipt, active native root ancestry and matching
+    Task/Change/Execution/Run. Environment IDs or a profile title alone never authorize recovery.
+    Other callers require a confirmed human Decision explicitly authorizing this lock recovery.
+    Declared project policy is not proof of effective host permissions; runtime profile selection
+    remains unavailable when the host does not expose it, and host denials must never be bypassed.
+    The command verifies the real
     Git dir (including linked worktrees), a regular empty lock older than ten minutes,
     no active Git process or operation marker, and a stable second stat; it moves the lock
     to a verified backup. An inconclusive check refuses recovery. Preserve that backup
@@ -60,3 +74,17 @@ the supplied ID and canonical record; never scan ordinary history to guess a tar
 
 Use `$zaip-skill-reconcile-telemetry` only for missing observed usage after lifecycle
 identity is correct; it is not a substitute for closure.
+
+For a root already closed by Stop with no Gui decision, use the restricted
+[late administrative assessment](references/late-finalization.md). Preserve the
+historical Run and blocked graph; a real current Gui assessment can only retain
+`blocked` and enable the existing recovery path, never approve delivery.
+
+For an empty usage-attribution lock on Windows, follow
+[native empty-lock recovery](references/empty-usage-lock.md). It requires authorized
+maintenance and exclusive inspection/rename through the same native file handle.
+Never delete the lock, infer a dead owner from age, or use the Git lock procedure.
+
+For an active owner whose published local-catalog cycle fails the final candidate
+gate, follow [signed local closure](references/local-catalog-closure.md). Input
+locations are discovery data only; never substitute them for authenticated proof.