@wave-ai-os/wave-cli 0.1.57

package/scripts/verify-dev-api.mjs

@@ -0,0 +1,1878 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+
+function loadDotEnv(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const env = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) continue;
+    const [, key, value] = match;
+    env[key] = value;
+  }
+  return env;
+}
+
+function runWave(args, env) {
+  const child = spawnSync("node", ["dist/index.js", ...args], {
+    env: { ...process.env, ...env },
+    encoding: "utf8"
+  });
+
+  const stdout = child.stdout?.trim() ?? "";
+  let parsed = null;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    parsed = null;
+  }
+
+  return {
+    args,
+    code: child.status ?? 1,
+    stdout,
+    stderr: child.stderr?.trim() ?? "",
+    parsed
+  };
+}
+
+function firstId(parsed, field) {
+  const root = parsed?.data;
+  if (!root || typeof root !== "object") {
+    return undefined;
+  }
+
+  const lookup = root;
+  const candidates = [];
+  if (field) {
+    candidates.push(field);
+  }
+  for (const key of Object.keys(lookup)) {
+    if (!candidates.includes(key)) {
+      candidates.push(key);
+    }
+  }
+
+  for (const key of candidates) {
+    const data = lookup[key];
+    if (data?.data?.[0]?.id) return String(data.data[0].id);
+    if (data?.id) return String(data.id);
+  }
+  return undefined;
+}
+
+function firstListRow(parsed, fields) {
+  for (const field of fields) {
+    const row = parsed?.data?.[field]?.data?.[0];
+    if (row && typeof row === "object") {
+      return row;
+    }
+  }
+  return undefined;
+}
+
+function classify(result) {
+  if (!result.parsed) {
+    return { ok: false, reason: "non_json_output" };
+  }
+  const embeddedError = findFirstEmbeddedErrors(result.parsed);
+  if (result.parsed.ok === true) {
+    if (embeddedError) {
+      return {
+        ok: false,
+        reason: "embedded_errors",
+        details: { path: embeddedError.path, sample: embeddedError.sample }
+      };
+    }
+    return { ok: true, reason: "ok" };
+  }
+
+  const code = result.parsed?.error?.code ?? "unknown";
+  const message = result.parsed?.error?.message ?? "";
+  const details = JSON.stringify(result.parsed?.error?.details ?? {});
+  const output = `${result.stdout}\n${result.stderr}`;
+  if (/unpermitted parameter/i.test(output) || /unpermitted parameter/i.test(details)) {
+    return { ok: false, reason: "unpermitted_parameter" };
+  }
+  const hardFailures = [
+    "network_error",
+    "missing_auth",
+    "generic_error"
+  ];
+  if (hardFailures.includes(code)) {
+    return { ok: false, reason: code };
+  }
+  if (
+    details.includes("missingRequiredArguments") ||
+    details.includes("argumentNotAccepted") ||
+    details.includes("undefinedField") ||
+    details.includes("variableNotUsed")
+  ) {
+    return { ok: false, reason: "graphql_contract_error" };
+  }
+  if (code === "invalid_args" && message.includes("Missing required create fields")) {
+    return { ok: true, reason: "skipped_missing_parent_dependency" };
+  }
+  if (result.parsed?.status === 422 && code === "VALIDATION_ERROR") {
+    return { ok: true, reason: "domain_validation_error" };
+  }
+  if (code === "invalid_args") {
+    return { ok: false, reason: code };
+  }
+  return { ok: true, reason: `reachable_${code}` };
+}
+
+function isNonEmptyErrorsValue(value) {
+  if (value === null || value === undefined) return false;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return false;
+    return value.some((entry) => {
+      if (entry === null || entry === undefined) return false;
+      if (typeof entry === "string") return entry.trim().length > 0;
+      if (typeof entry === "object") return Object.keys(entry).length > 0;
+      return true;
+    });
+  }
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+
+function summarizeValue(value) {
+  try {
+    if (typeof value === "string") return value.slice(0, 160);
+    const serialized = JSON.stringify(value);
+    if (typeof serialized !== "string") return String(value);
+    return serialized.slice(0, 300);
+  } catch {
+    return String(value);
+  }
+}
+
+function findFirstEmbeddedErrors(input) {
+  const queue = [{ value: input, path: "$", depth: 0 }];
+  const maxDepth = 12;
+  const maxNodes = 2000;
+  let visited = 0;
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) break;
+    visited += 1;
+    if (visited > maxNodes) break;
+
+    const { value, path, depth } = current;
+    if (!value || typeof value !== "object") continue;
+
+    if (Array.isArray(value)) {
+      if (depth >= maxDepth) continue;
+      for (let i = 0; i < value.length; i += 1) {
+        queue.push({ value: value[i], path: `${path}[${i}]`, depth: depth + 1 });
+      }
+      continue;
+    }
+
+    for (const [key, nested] of Object.entries(value)) {
+      const nextPath = `${path}.${key}`;
+      if (key === "errors" && isNonEmptyErrorsValue(nested)) {
+        return { path: nextPath, sample: summarizeValue(nested) };
+      }
+      if (depth < maxDepth && nested && typeof nested === "object") {
+        queue.push({ value: nested, path: nextPath, depth: depth + 1 });
+      }
+    }
+  }
+
+  return null;
+}
+
+function payload(root, attrs) {
+  return JSON.stringify({ [root]: attrs });
+}
+
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function extractListIds(parsed, field) {
+  const rows = parsed?.data?.[field]?.data;
+  if (!Array.isArray(rows)) return [];
+  return rows
+    .map((row) => (row?.id ? String(row.id) : ""))
+    .filter((id) => id.length > 0);
+}
+
+function readPath(input, segments) {
+  let current = input;
+  for (const segment of segments) {
+    if (!current || typeof current !== "object") {
+      return undefined;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+
+function firstDefinedValue(input, paths) {
+  for (const path of paths) {
+    const value = readPath(input, path);
+    if (value !== undefined && value !== null) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function verifySubissueDeleteWithPolling(env, issueId, subIssueId) {
+  const attempts = [];
+  for (let i = 1; i <= 5; i += 1) {
+    const listRes = runWave(["subissues", "list", "--issue-id", issueId], env);
+    const ids = extractListIds(listRes.parsed, "sub_issues");
+    const deleted = !ids.includes(String(subIssueId));
+    attempts.push({ index: i, ids, result: listRes });
+    if (deleted) {
+      return { ok: true, attempts, tries: i };
+    }
+    if (i < 5) {
+      sleepMs(500);
+    }
+  }
+  return { ok: false, attempts, tries: 5 };
+}
+
+function isValidationErrorResult(result) {
+  return result?.parsed?.status === 422 && result?.parsed?.error?.code === "VALIDATION_ERROR";
+}
+
+function extractValidationMessages(result) {
+  const errors = result?.parsed?.error?.details?.errors?.data;
+  if (!Array.isArray(errors)) return [];
+  return errors
+    .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+    .filter((entry) => entry.length > 0);
+}
+
+function startsWithArgs(args, prefix) {
+  if (!Array.isArray(args)) return false;
+  if (args.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i += 1) {
+    if (args[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+
+function findFirstResultByPrefix(results, prefix) {
+  return results.find((entry) => startsWithArgs(entry.args, prefix));
+}
+
+function cloneArgs(args) {
+  return Array.isArray(args) ? [...args] : [];
+}
+
+function parseDataJsonFromArgs(args) {
+  const idx = args.indexOf("--data-json");
+  if (idx < 0 || idx + 1 >= args.length) return null;
+  try {
+    const parsed = JSON.parse(String(args[idx + 1]));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function withUpdatedDataJson(args, nextPayload) {
+  const idx = args.indexOf("--data-json");
+  if (idx < 0 || idx + 1 >= args.length) return args;
+  const next = cloneArgs(args);
+  next[idx + 1] = JSON.stringify(nextPayload);
+  return next;
+}
+
+function getArgValue(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx < 0 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+function isoDatePlusDays(isoDate, days) {
+  const date = new Date(`${isoDate}T00:00:00Z`);
+  if (Number.isNaN(date.getTime())) return null;
+  date.setUTCDate(date.getUTCDate() + days);
+  return date.toISOString().slice(0, 10);
+}
+
+function summarizeStatus(result) {
+  const status = result?.parsed?.status ?? "n/a";
+  const err = result?.parsed?.error?.code ?? "none";
+  return `status=${status},err=${err}`;
+}
+
+function firstArrayValue(input, paths) {
+  for (const path of paths) {
+    const value = readPath(input, path);
+    if (Array.isArray(value)) {
+      return value;
+    }
+  }
+  return [];
+}
+
+function recordExactCheck({ lines, label, result, ok, reason }) {
+  const status = result?.parsed?.status ?? "n/a";
+  const errCode = result?.parsed?.error?.code ?? "none";
+  lines.push(
+    `${ok ? "PASS" : "FAIL"} | status=${status} | err=${errCode} | reason=${
+      reason || (ok ? "ok" : "assertion_failed")
+    } | ${label} (${result?.args?.join(" ") ?? "n/a"})`
+  );
+  return ok ? 0 : 1;
+}
+
+function resolveAnnualStrategicObjectiveId(result) {
+  return firstDefinedValue(result?.parsed, [
+    ["data", "annual_objective", "attributes", "strategicObjectiveId"],
+    ["data", "annual_objective", "attributes", "strategic_objective_id"],
+    ["data", "annual_objective", "strategicObjectiveId"],
+    ["data", "annual_objective", "strategic_objective_id"]
+  ]);
+}
+
+const root = process.cwd();
+const envFile = resolve(root, ".env");
+const dot = loadDotEnv(envFile);
+const env = {
+  WAVE_API_BASE_URL: dot.WAVE_API_BASE_URL,
+  WAVE_API_TOKEN: dot.WAVE_API_TOKEN,
+  WAVE_ORGANIZATION_ID: dot.WAVE_ORGANIZATION_ID,
+  WAVE_AGENT_NAME: dot.WAVE_AGENT_NAME || "cli-verifier",
+  WAVE_AGENT_RUN_ID: `verify-${Date.now()}`,
+  WAVE_TIMEOUT_MS: dot.WAVE_TIMEOUT_MS || "10000"
+};
+
+const idLookup = {};
+const listSeeds = [
+  ["projects", ["projects", "list", "--page", "1", "--per", "2"]],
+  ["tasks", ["tasks", "list", "--page", "1", "--per", "2"]],
+  ["rocks", ["rocks", "list", "--page", "1", "--per", "2"]],
+  ["meetings", ["meetings", "list", "--per", "2"]],
+  ["members", ["members", "list", "--page", "1", "--per", "2"]],
+  ["teams", ["teams", "list", "--page", "1", "--per", "2"]],
+  ["issues", ["issues", "list", "--page", "1", "--per", "2"]],
+  ["lists", ["lists", "list", "--page", "1", "--per", "2"]],
+  ["listItems", ["list-items", "list", "--page", "1", "--per", "2"]],
+  ["issueGroups", ["issue-groups", "list", "--page", "1", "--per", "2"]],
+  ["todoGroups", ["todo-groups", "list", "--page", "1", "--per", "2"]],
+  ["todos", ["todos", "list", "--page", "1", "--per", "2"]],
+  ["rockCollections", ["rock-collections", "list", "--page", "1", "--per", "2"]],
+  ["knowledge", ["knowledge", "list", "--page", "1", "--per", "2"]],
+  ["standUps", ["stand-ups", "list", "--page", "1", "--per", "2"]],
+  ["news", ["news", "list", "--page", "1", "--per", "2"]],
+  ["questions", ["questions", "list", "--page", "1", "--per", "2"]],
+  ["pulse", ["pulse", "list", "--page", "1", "--per", "2"]],
+  ["surveys", ["surveys", "list", "--page", "1", "--per", "2"]],
+  ["feedbacks", ["feedbacks", "list", "--page", "1", "--per", "2"]],
+  ["accountability", ["accountability", "list", "--page", "1", "--per", "2"]],
+  ["kpis", ["kpis", "list", "--page", "1", "--per", "2"]],
+  ["scorecardGroups", ["scorecard-groups", "list", "--page", "1", "--per", "2"]],
+  ["scorecards", ["scorecards", "list", "--page", "1", "--per", "2"]],
+  ["customers", ["customers", "list", "--page", "1", "--per", "2"]],
+  ["contacts", ["contacts", "list", "--page", "1", "--per", "2"]],
+  ["annualObjectives", ["foundation", "annual-objectives", "list", "--page", "1", "--per", "2"]],
+  ["quarterlyObjectives", ["foundation", "quarterly-objectives", "list", "--page", "1", "--per", "2"]]
+];
+
+const results = [];
+for (const [key, args] of listSeeds) {
+  const res = runWave(args, env);
+  results.push(res);
+  if (res.parsed?.ok) {
+    const field = args[0] === "foundation" ? args[1].replace(/-([a-z])/g, (_, c) => c.toUpperCase()) : args[0].replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    idLookup[key] = firstId(res.parsed, field);
+    if (key === "kpis") {
+      const firstKpi = firstListRow(res.parsed, ["smart_kpis", "smartKpis", "kpis"]);
+      if (firstKpi && typeof firstKpi === "object") {
+        const attributes = firstKpi.attributes;
+        if (attributes && typeof attributes === "object") {
+          const attr = attributes;
+          idLookup.kpiSmartKpiViewId =
+            typeof attr.smart_kpi_view_id === "string"
+              ? attr.smart_kpi_view_id
+              : typeof attr.smartKpiViewId === "string"
+                ? attr.smartKpiViewId
+                : undefined;
+          idLookup.kpiCreateName =
+            typeof attr.name === "string" && attr.name.trim().length > 0 ? attr.name : undefined;
+        }
+      }
+    }
+  }
+}
+
+const orgId = env.WAVE_ORGANIZATION_ID;
+const projectId = idLookup.projects;
+const taskId = idLookup.tasks;
+const rockId = idLookup.rocks;
+const meetingId = idLookup.meetings;
+const memberId = idLookup.members;
+const teamId = idLookup.teams;
+const issueId = idLookup.issues;
+const issueGroupId = idLookup.issueGroups;
+const listId = idLookup.lists;
+const listItemId = idLookup.listItems;
+const todoGroupId = idLookup.todoGroups;
+const todoId = idLookup.todos;
+const rockCollectionId = idLookup.rockCollections;
+const contentId = idLookup.knowledge;
+const standUpId = idLookup.standUps;
+const headlineId = idLookup.news;
+const questionId = idLookup.questions;
+const pulseId = idLookup.pulse;
+const surveyId = idLookup.surveys;
+const feedbackId = idLookup.feedbacks;
+const responsibilityId = idLookup.accountability;
+const kpiId = idLookup.kpis;
+const kpiSmartKpiViewId = idLookup.kpiSmartKpiViewId;
+const kpiCreateName = idLookup.kpiCreateName;
+const measurableGroupId = idLookup.scorecardGroups;
+const measurableId = idLookup.scorecards;
+const customerId = idLookup.customers;
+const contactId = idLookup.contacts;
+const annualObjectiveId = idLookup.annualObjectives;
+const quarterlyObjectiveId = idLookup.quarterlyObjectives;
+const verifyStamp = String(Date.now());
+const orgWorkspaceNameVerify = `Wave Verify ${verifyStamp}`;
+const orgMetaOneSentenceSummaryVerify = `Verify Title ${verifyStamp}`;
+const keyMetricRevenueVerify = String(1000 + Number(verifyStamp.slice(-3)));
+const questionNameVerify = `CLI Verify Question Update ${verifyStamp}`;
+const surveyDueDateVerify = "2026-12-31";
+const feedbackQuarterVerify = "q3";
+const accountabilityNameVerify = `CLI Verify Responsibility Update ${verifyStamp}`;
+const organizationMetaProfileSeed = runWave(
+  ["organizations", "meta-profile", "show", "--id", orgId],
+  env
+);
+results.push(organizationMetaProfileSeed);
+const organizationMetaProfileId =
+  firstId(organizationMetaProfileSeed.parsed, "organization_meta_profile") ?? orgId;
+const keyMetricMetaProfileSeed = runWave(
+  ["organizations", "key-metric-meta-profile", "show", "--id", orgId],
+  env
+);
+results.push(keyMetricMetaProfileSeed);
+const keyMetricMetaProfileId =
+  firstId(keyMetricMetaProfileSeed.parsed, "key_metric_meta_profile") ?? orgId;
+const meetingCreatePayload = teamId
+  ? {
+      name: "CLI Verify Meeting",
+      type: "TeamMeeting",
+      member_id: memberId,
+      date: "2026-04-18",
+      start_time: 700,
+      end_time: 760,
+      repeats: "never",
+      status: "upcoming",
+      teams_ids: [teamId]
+    }
+  : {
+      name: "CLI Verify Meeting",
+      type: "OneOnOneMeeting",
+      member_id: memberId,
+      date: "2026-04-18",
+      start_time: 700,
+      repeats: "never",
+      status: "upcoming"
+    };
+
+const probes = [
+  ["projects", "show", "--id", projectId],
+  ["tasks", "show", "--id", taskId],
+  ["rocks", "show", "--id", rockId],
+  ["meetings", "show", "--id", meetingId],
+  ["members", "show", "--id", memberId],
+  ["teams", "show", "--id", teamId],
+  ["issues", "show", "--id", issueId],
+  ["lists", "show", "--id", listId],
+  ["list-items", "show", "--id", listItemId],
+  ["issue-groups", "show", "--id", issueGroupId],
+  ["todo-groups", "show", "--id", todoGroupId],
+  ["todos", "show", "--id", todoId],
+  ["rock-collections", "show", "--id", rockCollectionId],
+  ["knowledge", "show", "--id", contentId],
+  ["stand-ups", "show", "--id", standUpId],
+  ["news", "show", "--id", headlineId],
+  ["questions", "show", "--id", questionId],
+  ["pulse", "show", "--id", pulseId],
+  ["surveys", "show", "--id", surveyId],
+  ["feedbacks", "show", "--id", feedbackId],
+  ["accountability", "show", "--id", responsibilityId],
+  ["kpis", "show", "--id", kpiId],
+  ["scorecard-groups", "show", "--id", measurableGroupId],
+  ["scorecards", "show", "--id", measurableId],
+  ["customers", "show", "--id", customerId],
+  ["contacts", "show", "--id", contactId],
+  ["organizations", "show", "--id", orgId],
+  ["organizations", "meta-profile", "show", "--id", orgId],
+  ["organizations", "key-metric-meta-profile", "show", "--id", orgId],
+  ["foundation", "strategic-plans", "show", "--id", orgId],
+  ["foundation", "strategic-objectives", "show", "--id", orgId],
+  ["foundation", "annual-objectives", "show", "--id", annualObjectiveId],
+  ["foundation", "quarterly-objectives", "show", "--id", quarterlyObjectiveId],
+  ["projects", "create", "--data-json", payload("project", { name: "CLI Verify Project", status: "backlog", priority: "no_priority" })],
+  ["projects", "update", "--id", projectId, "--data-json", payload("project", { description: "verify-update" })],
+  ["tasks", "create", "--project-id", projectId, "--summary", "CLI verify task"],
+  ["tasks", "update", "--id", taskId, "--summary", "CLI verify task update"],
+  ["rocks", "update-status", "--id", rockId, "--status", "on_track"],
+  ["rocks", "create", "--data-json", payload("rock", { name: "CLI Verify Rock", rock_collection_id: rockCollectionId, status: "on_track", priority: "no_priority", rock_type: "individual" })],
+  ["rocks", "update", "--id", rockId, "--data-json", payload("rock", { description: "verify-update" })],
+  ["meetings", "notes", "--id", meetingId, "--content", "CLI verify notes"],
+  ["meetings", "create", "--data-json", payload("meeting", meetingCreatePayload)],
+  ["meetings", "update", "--id", meetingId, "--data-json", payload("meeting", { notes: "verify-update" })],
+  ["members", "create", "--data-json", payload("member", { email: `cli.verify.${Date.now()}@example.com` })],
+  ["members", "update", "--id", memberId, "--data-json", payload("member", { first_name: "CLI" })],
+  ["teams", "create", "--data-json", payload("team", { name: `CLI Verify Team ${Date.now()}` })],
+  ["teams", "update", "--id", teamId, "--data-json", payload("team", { name: `CLI Verify Team Update ${Date.now()}` })],
+  ["organizations", "update", "--id", orgId, "--data-json", payload("organization", { organization_detail_attributes: { workspace_name: orgWorkspaceNameVerify } })],
+  ["organizations", "meta-profile", "update", "--id", organizationMetaProfileId, "--data-json", payload("organization_meta_profile", { profile: { company_identity: { one_sentence_summary: orgMetaOneSentenceSummaryVerify } } })],
+  ["organizations", "key-metric-meta-profile", "update", "--id", keyMetricMetaProfileId, "--data-json", payload("key_metric_meta_profile", { profile: { financial: { revenue: keyMetricRevenueVerify } } })],
+  ["issues", "create", "--issue-group-id", issueGroupId, "--name", "CLI Verify Issue", "--issue-type", "short_term"],
+  ["issues", "update", "--id", issueId, "--data-json", payload("issue", { description: "verify-update" })],
+  ["lists", "create", "--data-json", payload("list", { name: "CLI Verify List", status: "in_progress", priority: "no_priority" })],
+  ["lists", "update", "--id", listId, "--data-json", payload("list", { description: "verify-update" })],
+  ["list-items", "create", "--data-json", payload("list_item", { list_id: listId, summary: "CLI Verify List Item" })],
+  ["list-items", "update", "--id", listItemId, "--data-json", payload("list_item", { summary: "CLI Verify List Item Update" })],
+  ["issue-groups", "create", "--data-json", payload("issue_group", { name: "CLI Verify Issue Group", status: "in_progress", priority: "no_priority" })],
+  ["issue-groups", "update", "--id", issueGroupId, "--data-json", payload("issue_group", { description: "verify-update" })],
+  ["todo-groups", "create", "--data-json", payload("todo_group", { name: "CLI Verify Todo Group", status: "in_progress", priority: "no_priority" })],
+  ["todo-groups", "update", "--id", todoGroupId, "--data-json", payload("todo_group", { description: "verify-update" })],
+  ["todos", "create", "--data-json", payload("todo", { todo_group_id: todoGroupId, name: "CLI Verify Todo", status: "open", priority: "no_priority" })],
+  ["todos", "update", "--id", todoId, "--data-json", payload("todo", { description: "verify-update" })],
+  ["rock-collections", "create", "--data-json", payload("rock_collection", { name: "CLI Verify Rock Collection", status: "in_progress", priority: "no_priority" })],
+  ["rock-collections", "update", "--id", rockCollectionId, "--data-json", payload("rock_collection", { description: "verify-update" })],
+  ["knowledge", "create", "--data-json", payload("content", { content_type: "process", status: "draft", name: "CLI Verify Doc", member_id: memberId })],
+  ["knowledge", "update", "--id", contentId, "--data-json", payload("content", { name: "CLI Verify Doc Update" })],
+  ["stand-ups", "create", "--data-json", payload("stand_up", { member_id: memberId, completed_date: "2026-04-06" })],
+  ["stand-ups", "update", "--id", standUpId, "--data-json", payload("stand_up", { blockers: "verify-update" })],
+  ["news", "create", "--data-json", payload("headline", { summary: "CLI Verify Headline", member_id: memberId, status: "active", headline_type: "org_wide" })],
+  ["news", "update", "--id", headlineId, "--data-json", payload("headline", { description: "verify-update" })],
+  ["questions", "create", "--data-json", payload("question", { name: "CLI Verify Question", member_id: memberId })],
+  ["questions", "update", "--id", questionId, "--data-json", payload("question", { name: questionNameVerify, description: "verify-update" })],
+  ["pulse", "create", "--data-json", payload("health_update", { health_updatable_id: projectId, health_updatable_type: "Project", member_id: memberId, value: "on_track", status: "on_track" })],
+  ["pulse", "update", "--id", pulseId, "--data-json", payload("health_update", { value: "verify-update" })],
+  ["surveys", "create", "--data-json", payload("survey", { name: "engagement", recipient_type: "org_wide" })],
+  ["surveys", "update", "--id", surveyId, "--data-json", payload("survey", { name: "engagement", recipient_type: "org_wide", due_date: surveyDueDateVerify })],
+  ["feedbacks", "create", "--data-json", payload("feedback", { name: "company_culture", quarter: "q2", year: "2026" })],
+  ["feedbacks", "update", "--id", feedbackId, "--data-json", payload("feedback", { name: "roadmap_and_strategy", quarter: feedbackQuarterVerify, year: "2026" })],
+  ["accountability", "create", "--data-json", payload("responsibility", { name: "CLI Verify Responsibility", member_id: memberId })],
+  ["accountability", "update", "--id", responsibilityId, "--data-json", payload("responsibility", { name: accountabilityNameVerify })],
+  ["kpis", "create", "--data-json", payload("smart_kpi", { smart_kpi_view_id: kpiSmartKpiViewId, name: kpiCreateName })],
+  ["kpis", "update", "--id", kpiId, "--data-json", payload("smart_kpi", { name: "CLI Verify KPI Update" })],
+  ["scorecard-groups", "create", "--data-json", payload("measurable_group", { name: "CLI Verify Scorecard Group" })],
+  ["scorecard-groups", "update", "--id", measurableGroupId, "--data-json", payload("measurable_group", { name: "CLI Verify Scorecard Group Update" })],
+  ["scorecards", "create", "--data-json", payload("measurable", { measurable_group_id: measurableGroupId, name: "CLI Verify Scorecard", interval: "weekly", trend: "average" })],
+  ["scorecards", "update", "--id", measurableId, "--data-json", payload("measurable", { name: "CLI Verify Scorecard Update" })],
+  ["customers", "create", "--data-json", payload("customer", { name: "CLI Verify Customer" })],
+  ["customers", "update", "--id", customerId, "--data-json", payload("customer", { name: "CLI Verify Customer Update" })],
+  ["contacts", "create", "--data-json", payload("contact", { customer_id: customerId, name: "CLI Verify Contact" })],
+  ["contacts", "update", "--id", contactId, "--data-json", payload("contact", { name: "CLI Verify Contact Update" })],
+  ["foundation", "strategic-plans", "update", "--id", orgId, "--data-json", payload("strategic_plan", { published_at: "2026-04-18T17:00:00Z" })],
+  ["foundation", "strategic-objectives", "update", "--id", orgId, "--data-json", payload("strategic_objective", { summary: "CLI Verify Strategic Objective" })],
+  ["foundation", "annual-objectives", "create", "--data-json", payload("annual_objective", { strategic_objective_id: annualObjectiveId || orgId, name: "CLI Verify Annual Objective" })],
+  ["foundation", "annual-objectives", "update", "--id", annualObjectiveId, "--data-json", payload("annual_objective", { name: "CLI Verify Annual Objective Update" })],
+  ["foundation", "quarterly-objectives", "create", "--data-json", payload("quarterly_objective", { strategic_objective_id: annualObjectiveId || orgId, annual_objective_id: annualObjectiveId || orgId, name: "CLI Verify Quarterly Objective" })],
+  ["foundation", "quarterly-objectives", "update", "--id", quarterlyObjectiveId, "--data-json", payload("quarterly_objective", { name: "CLI Verify Quarterly Objective Update" })]
+];
+
+for (const args of probes) {
+  if (args.includes(undefined)) {
+    results.push({
+      args,
+      code: 0,
+      stdout: JSON.stringify({
+        ok: false,
+        error: { code: "skipped_missing_id", details: {} }
+      }),
+      parsed: { ok: false, error: { code: "skipped_missing_id", details: {} } }
+    });
+    continue;
+  }
+  results.push(runWave(args, env));
+}
+
+const validationRemediationEntries = [];
+let validationRemediationFailures = 0;
+let feedbackQuarterExpected = feedbackQuarterVerify;
+
+function recordValidationRemediation(entry) {
+  validationRemediationEntries.push(entry);
+}
+
+function remediateStandupsCreateDuplicateDate() {
+  const operation = "stand-ups.create";
+  const initial = findFirstResultByPrefix(results, ["stand-ups", "create"]);
+  if (!initial) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["stand_up.completed_date"],
+      backendMessage: "initial probe missing",
+      initialResult: "missing",
+      remediation: "none",
+      finalResult: "missing"
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const messages = extractValidationMessages(initial);
+  const isDuplicateDateValidation =
+    isValidationErrorResult(initial) &&
+    messages.some((msg) => /completed date.*already been taken/i.test(msg));
+
+  if (!isDuplicateDateValidation) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["stand_up.completed_date"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "none_not_required",
+      finalResult: summarizeStatus(initial)
+    });
+    return;
+  }
+
+  const initialPayload = parseDataJsonFromArgs(initial.args);
+  const standUpBody =
+    initialPayload && typeof initialPayload.stand_up === "object" ? initialPayload.stand_up : null;
+  const baseDate =
+    standUpBody && typeof standUpBody.completed_date === "string"
+      ? standUpBody.completed_date
+      : "2026-04-06";
+
+  if (!standUpBody || typeof standUpBody.member_id !== "string") {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["stand_up.member_id", "stand_up.completed_date"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_member_or_payload",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const attemptedDates = [];
+  let finalResult = initial;
+  let remediation = "retry_create_with_next_date";
+  for (let offset = 1; offset <= 7; offset += 1) {
+    const candidateDate = isoDatePlusDays(baseDate, offset);
+    if (!candidateDate) continue;
+    attemptedDates.push(candidateDate);
+    const nextPayload = {
+      stand_up: {
+        ...standUpBody,
+        completed_date: candidateDate
+      }
+    };
+    const retryArgs = withUpdatedDataJson(initial.args, nextPayload);
+    const retryResult = runWave(retryArgs, env);
+    results.push(retryResult);
+    finalResult = retryResult;
+    if (retryResult.parsed?.ok === true) {
+      remediation = `retry_create_with_next_date_success base=${baseDate} chosen=${candidateDate}`;
+      break;
+    }
+    const retryMessages = extractValidationMessages(retryResult);
+    const stillDuplicate = retryMessages.some((msg) =>
+      /completed date.*already been taken/i.test(msg)
+    );
+    if (!stillDuplicate) {
+      remediation = `retry_create_with_next_date_stopped_non_duplicate_error at=${candidateDate}`;
+      break;
+    }
+    remediation = `retry_create_with_next_date_exhausting base=${baseDate}`;
+  }
+
+  recordValidationRemediation({
+    operation,
+    offendingFields: ["stand_up.completed_date"],
+    backendMessage: messages[0] ?? "",
+    initialResult: summarizeStatus(initial),
+    remediation: `${remediation};attempted_dates=${attemptedDates.join(",")}`,
+    finalResult: summarizeStatus(finalResult)
+  });
+
+  if (finalResult.parsed?.ok !== true) {
+    validationRemediationFailures += 1;
+  }
+}
+
+function remediateFeedbacksUpdateDuplicateName() {
+  const operation = "feedbacks.update";
+  const initial = findFirstResultByPrefix(results, ["feedbacks", "update"]);
+  if (!initial) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name"],
+      backendMessage: "initial probe missing",
+      initialResult: "missing",
+      remediation: "none",
+      finalResult: "missing"
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const messages = extractValidationMessages(initial);
+  const isDuplicateNameValidation =
+    isValidationErrorResult(initial) &&
+    messages.some((msg) => /name has already been taken/i.test(msg));
+
+  if (!isDuplicateNameValidation) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "none_not_required",
+      finalResult: summarizeStatus(initial)
+    });
+    return;
+  }
+
+  const initialPayload = parseDataJsonFromArgs(initial.args);
+  const feedbackBody =
+    initialPayload && typeof initialPayload.feedback === "object" ? initialPayload.feedback : null;
+  const originalName =
+    feedbackBody && typeof feedbackBody.name === "string" ? feedbackBody.name : "feedback";
+
+  if (!feedbackBody) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_feedback_payload",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const feedbackId = getArgValue(initial.args, "--id");
+  if (!feedbackId) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name", "feedback.year"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_feedback_id",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const showArgs = ["feedbacks", "show", "--id", String(feedbackId)];
+  const showResult = runWave(showArgs, env);
+  results.push(showResult);
+
+  const currentName = firstDefinedValue(showResult?.parsed, [
+    ["data", "feedback", "attributes", "name"],
+    ["data", "feedback", "name"]
+  ]);
+  const currentQuarter = firstDefinedValue(showResult?.parsed, [
+    ["data", "feedback", "attributes", "quarter"],
+    ["data", "feedback", "quarter"]
+  ]);
+  const currentYear = firstDefinedValue(showResult?.parsed, [
+    ["data", "feedback", "attributes", "year"],
+    ["data", "feedback", "year"]
+  ]);
+
+  if (!showResult.parsed?.ok || !currentName || !currentQuarter) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["feedback.name", "feedback.year"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: `failed_feedback_show_lookup id=${feedbackId};lookup=${summarizeStatus(showResult)}`,
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const parsedYear = Number.parseInt(String(currentYear ?? ""), 10);
+  const remediatedYear = Number.isFinite(parsedYear) ? parsedYear + 1 : 2030;
+  const nextPayload = {
+    feedback: {
+      ...feedbackBody,
+      name: String(currentName),
+      quarter: String(currentQuarter),
+      year: String(remediatedYear)
+    }
+  };
+  const retryArgs = withUpdatedDataJson(initial.args, nextPayload);
+  const finalResult = runWave(retryArgs, env);
+  results.push(finalResult);
+
+  recordValidationRemediation({
+    operation,
+    offendingFields: ["feedback.name", "feedback.year"],
+    backendMessage: messages[0] ?? "",
+    initialResult: summarizeStatus(initial),
+    remediation:
+      `fallback_non_unique_field original_name=${originalName}` +
+      ` remediated_name=${String(currentName)}` +
+      ` remediated_quarter=${String(currentQuarter)}` +
+      ` remediated_year=${String(remediatedYear)}`,
+    finalResult: summarizeStatus(finalResult)
+  });
+
+  if (finalResult.parsed?.ok !== true) {
+    validationRemediationFailures += 1;
+  } else {
+    feedbackQuarterExpected = String(currentQuarter);
+  }
+}
+
+function remediateQuarterlyObjectiveParentMismatch() {
+  const operation = "foundation.quarterly-objectives.create";
+  const initial = findFirstResultByPrefix(results, [
+    "foundation",
+    "quarterly-objectives",
+    "create"
+  ]);
+  if (!initial) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: "initial probe missing",
+      initialResult: "missing",
+      remediation: "none",
+      finalResult: "missing"
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const messages = extractValidationMessages(initial);
+  const isParentMismatchValidation =
+    isValidationErrorResult(initial) &&
+    messages.some((msg) =>
+      /belongs to strategic_objective_id|matching strategic_objective_id/i.test(msg)
+    );
+
+  if (!isParentMismatchValidation) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "none_not_required",
+      finalResult: summarizeStatus(initial)
+    });
+    return;
+  }
+
+  const initialPayload = parseDataJsonFromArgs(initial.args);
+  const quarterlyBody =
+    initialPayload && typeof initialPayload.quarterly_objective === "object"
+      ? initialPayload.quarterly_objective
+      : null;
+  const annualId =
+    quarterlyBody && typeof quarterlyBody.annual_objective_id === "string"
+      ? quarterlyBody.annual_objective_id
+      : "";
+
+  if (!quarterlyBody || annualId.length === 0) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: "failed_missing_annual_objective_id",
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const annualShowArgs = ["foundation", "annual-objectives", "show", "--id", annualId];
+  const annualShowResult = runWave(annualShowArgs, env);
+  results.push(annualShowResult);
+  const resolvedStrategicObjectiveId = resolveAnnualStrategicObjectiveId(annualShowResult);
+  if (!annualShowResult.parsed?.ok || !resolvedStrategicObjectiveId) {
+    recordValidationRemediation({
+      operation,
+      offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+      backendMessage: messages[0] ?? "",
+      initialResult: summarizeStatus(initial),
+      remediation: `failed_parent_lookup annual_id=${annualId};lookup=${summarizeStatus(annualShowResult)}`,
+      finalResult: summarizeStatus(initial)
+    });
+    validationRemediationFailures += 1;
+    return;
+  }
+
+  const nextPayload = {
+    quarterly_objective: {
+      ...quarterlyBody,
+      strategic_objective_id: String(resolvedStrategicObjectiveId),
+      annual_objective_id: annualId
+    }
+  };
+  const retryArgs = withUpdatedDataJson(initial.args, nextPayload);
+  const retryResult = runWave(retryArgs, env);
+  results.push(retryResult);
+
+  recordValidationRemediation({
+    operation,
+    offendingFields: ["quarterly_objective.annual_objective_id", "quarterly_objective.strategic_objective_id"],
+    backendMessage: messages[0] ?? "",
+    initialResult: summarizeStatus(initial),
+    remediation: `parent_match annual_id=${annualId} strategic_objective_id=${String(resolvedStrategicObjectiveId)}`,
+    finalResult: summarizeStatus(retryResult)
+  });
+
+  if (retryResult.parsed?.ok !== true) {
+    validationRemediationFailures += 1;
+  }
+}
+
+remediateStandupsCreateDuplicateDate();
+remediateFeedbacksUpdateDuplicateName();
+remediateQuarterlyObjectiveParentMismatch();
+
+let deleteVerifyLine = "";
+let deleteVerifyFailure = 0;
+if (issueId) {
+  const subissueCreate = runWave(
+    [
+      "subissues",
+      "create",
+      "--data-json",
+      payload("sub_issue", {
+        issue_id: issueId,
+        name: `CLI Verify Subissue ${Date.now()}`
+      })
+    ],
+    env
+  );
+  results.push(subissueCreate);
+  const subIssueId = subissueCreate?.parsed?.data?.create_sub_issue?.data?.data?.id
+    ? String(subissueCreate.parsed.data.create_sub_issue.data.data.id)
+    : "";
+  if (subIssueId) {
+    const destroyRes = runWave(["subissues", "destroy", "--id", subIssueId], env);
+    results.push(destroyRes);
+    const verifyRes = verifySubissueDeleteWithPolling(env, issueId, subIssueId);
+    deleteVerifyLine = `${verifyRes.ok ? "PASS" : "FAIL"} | status=${verifyRes.ok ? 200 : 500} | err=${
+      verifyRes.ok ? "none" : "delete_not_observed"
+    } | subissues destroy verify --issue-id ${issueId} --id ${subIssueId} --tries ${verifyRes.tries}`;
+    if (!verifyRes.ok) {
+      deleteVerifyFailure = 1;
+    }
+  }
+}
+
+const postUpdateVerificationLines = [];
+let postUpdateVerificationFailures = 0;
+const osmdVerificationLines = [];
+let osmdVerificationFailures = 0;
+
+function hasSuccessfulCommand(commandPrefix) {
+  return results.some((res) => {
+    if (!Array.isArray(res.args)) return false;
+    if (res.args.length < commandPrefix.length) return false;
+    for (let i = 0; i < commandPrefix.length; i += 1) {
+      if (res.args[i] !== commandPrefix[i]) {
+        return false;
+      }
+    }
+    return res.parsed?.ok === true;
+  });
+}
+
+function verifyFieldWrite({ label, showArgs, expectedValue, candidatePaths, requiredSuccessPrefix }) {
+  if (requiredSuccessPrefix && !hasSuccessfulCommand(requiredSuccessPrefix)) {
+    postUpdateVerificationLines.push(`PASS | status=n/a | err=skipped_prereq_not_ok | ${label}`);
+    return;
+  }
+
+  if (showArgs.includes(undefined)) {
+    postUpdateVerificationLines.push(`PASS | status=n/a | err=skipped_missing_id | ${label}`);
+    return;
+  }
+
+  const showRes = runWave(showArgs, env);
+  const status = showRes.parsed?.status ?? "n/a";
+  const errCode = showRes.parsed?.error?.code ?? "none";
+
+  if (!showRes.parsed?.ok) {
+    postUpdateVerificationLines.push(
+      `FAIL | status=${status} | err=${errCode} | ${label} (${showArgs.join(" ")})`
+    );
+    postUpdateVerificationFailures += 1;
+    return;
+  }
+
+  const actual = firstDefinedValue(showRes.parsed, candidatePaths);
+  const ok = String(actual ?? "") === String(expectedValue);
+  postUpdateVerificationLines.push(
+    `${ok ? "PASS" : "FAIL"} | status=${status} | err=${
+      ok ? "none" : "read_after_write_mismatch"
+    } | ${label} expected=${JSON.stringify(expectedValue)} actual=${JSON.stringify(actual ?? null)}`
+  );
+  if (!ok) {
+    postUpdateVerificationFailures += 1;
+  }
+}
+
+verifyFieldWrite({
+  label: "organizations.update verify workspace_name",
+  showArgs: ["organizations", "show", "--id", orgId],
+  expectedValue: orgWorkspaceNameVerify,
+  requiredSuccessPrefix: ["organizations", "update"],
+  candidatePaths: [
+    ["data", "organization", "organizationDetail", "workspaceName"],
+    ["data", "organization", "organization_detail", "workspace_name"],
+    ["data", "organization", "attributes", "organizationDetail", "workspaceName"],
+    ["data", "organization", "attributes", "organization_detail_attributes", "workspace_name"]
+  ]
+});
+
+verifyFieldWrite({
+  label: "organizations.meta-profile.update verify one_sentence_summary",
+  showArgs: ["organizations", "meta-profile", "show", "--id", organizationMetaProfileId],
+  expectedValue: orgMetaOneSentenceSummaryVerify,
+  requiredSuccessPrefix: ["organizations", "meta-profile", "update"],
+  candidatePaths: [
+    [
+      "data",
+      "organization_meta_profile",
+      "attributes",
+      "profile",
+      "companyIdentity",
+      "oneSentenceSummary"
+    ],
+    [
+      "data",
+      "organization_meta_profile",
+      "attributes",
+      "profile",
+      "company_identity",
+      "one_sentence_summary"
+    ],
+    [
+      "data",
+      "organizationMetaProfile",
+      "attributes",
+      "profile",
+      "companyIdentity",
+      "oneSentenceSummary"
+    ]
+  ]
+});
+
+verifyFieldWrite({
+  label: "organizations.key-metric-meta-profile.update verify financial.revenue",
+  showArgs: ["organizations", "key-metric-meta-profile", "show", "--id", keyMetricMetaProfileId],
+  expectedValue: keyMetricRevenueVerify,
+  requiredSuccessPrefix: ["organizations", "key-metric-meta-profile", "update"],
+  candidatePaths: [
+    ["data", "key_metric_meta_profile", "attributes", "profile", "financial", "revenue"],
+    ["data", "keyMetricMetaProfile", "attributes", "profile", "financial", "revenue"]
+  ]
+});
+
+verifyFieldWrite({
+  label: "questions.update verify name",
+  showArgs: ["questions", "show", "--id", questionId],
+  expectedValue: questionNameVerify,
+  requiredSuccessPrefix: ["questions", "update"],
+  candidatePaths: [
+    ["data", "question", "attributes", "name"],
+    ["data", "question", "attributes", "summary"]
+  ]
+});
+
+verifyFieldWrite({
+  label: "surveys.update verify due_date",
+  showArgs: ["surveys", "show", "--id", surveyId],
+  expectedValue: surveyDueDateVerify,
+  requiredSuccessPrefix: ["surveys", "update"],
+  candidatePaths: [
+    ["data", "survey", "attributes", "dueDate"],
+    ["data", "survey", "attributes", "due_date"]
+  ]
+});
+
+verifyFieldWrite({
+  label: "feedbacks.update verify quarter",
+  showArgs: ["feedbacks", "show", "--id", feedbackId],
+  expectedValue: feedbackQuarterExpected,
+  requiredSuccessPrefix: ["feedbacks", "update"],
+  candidatePaths: [["data", "feedback", "attributes", "quarter"]]
+});
+
+verifyFieldWrite({
+  label: "accountability.update verify name",
+  showArgs: ["accountability", "show", "--id", responsibilityId],
+  expectedValue: accountabilityNameVerify,
+  requiredSuccessPrefix: ["accountability", "update"],
+  candidatePaths: [["data", "responsibility", "attributes", "name"]]
+});
+
+function resolveOsmdAgentParentRef() {
+  const queries = ["Wave Tools", "Ted Martinez", "Ted"];
+  for (const query of queries) {
+    const findRes = runWave(["find", query, "--limit", "10"], env);
+    results.push(findRes);
+    const candidates = firstArrayValue(findRes.parsed, [["data", "candidates"]]);
+    for (const candidate of candidates) {
+      const canonicalPath =
+        candidate && typeof candidate === "object" && typeof candidate.canonicalPath === "string"
+          ? candidate.canonicalPath
+          : "";
+      if (!canonicalPath) continue;
+
+      const statusRes = runWave(["osmd", "status", canonicalPath], env);
+      results.push(statusRes);
+      if (
+        statusRes.parsed?.ok === true &&
+        statusRes.parsed?.data?.source === "canonical_osmd" &&
+        statusRes.parsed?.data?.exists === true &&
+        statusRes.parsed?.data?.agentChildrenAllowed === true
+      ) {
+        return String(statusRes.parsed.data.path || canonicalPath);
+      }
+    }
+  }
+  return null;
+}
+
+function runOsmdLiveVerification() {
+  const treeDepthZero = runWave(["osmd", "tree", "--depth", "0"], env);
+  results.push(treeDepthZero);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.tree depth 0 returns metadata and normalized empty children",
+    result: treeDepthZero,
+    ok:
+      treeDepthZero.parsed?.ok === true &&
+      treeDepthZero.parsed?.data?.source === "canonical_osmd" &&
+      Array.isArray(treeDepthZero.parsed?.data?.children) &&
+      treeDepthZero.parsed.data.children.length === 0,
+    reason: "depth_zero_contract"
+  });
+
+  const treeDepthOne = runWave(["osmd", "tree", "--depth", "1"], env);
+  results.push(treeDepthOne);
+  const treeChildren = Array.isArray(treeDepthOne.parsed?.data?.children)
+    ? treeDepthOne.parsed.data.children
+    : [];
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.tree depth 1 returns organization root and restored display folders",
+    result: treeDepthOne,
+    ok:
+      treeDepthOne.parsed?.ok === true &&
+      treeDepthOne.parsed?.data?.source === "canonical_osmd" &&
+      String(treeDepthOne.parsed?.data?.runtimeLabel ?? "").endsWith(".MD") &&
+      String(treeDepthOne.parsed?.data?.path ?? "").endsWith(".MD") &&
+      JSON.stringify(treeChildren.map((child) => child?.runtimeLabel)) ===
+        JSON.stringify(["Org", "Members", "Teams", "Tools", "Agent Wiki"]) &&
+      JSON.stringify(treeChildren.map((child) => child?.toolKey)) ===
+        JSON.stringify(["org", "directory", "directory", "osmd_display", "agent_wiki"]) &&
+      JSON.stringify(treeChildren.map((child) => child?.nodeKey)) ===
+        JSON.stringify(["root", "members", "teams", "tools", "root"]),
+    reason: "display_root_contract"
+  });
+
+  const wikiStatus = runWave(["osmd", "wiki", "status", "index.md"], env);
+  results.push(wikiStatus);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki status index",
+    result: wikiStatus,
+    ok:
+      wikiStatus.parsed?.ok === true &&
+      wikiStatus.parsed?.data?.path === "Agent Wiki/index.md" &&
+      wikiStatus.parsed?.data?.source === "agent_wiki" &&
+      wikiStatus.parsed?.data?.wikiRole === "index" &&
+      typeof wikiStatus.parsed?.data?.formatVersion === "string" &&
+      (wikiStatus.parsed?.data?.exists !== false ||
+        (wikiStatus.parsed?.data?.canCreate === true &&
+          wikiStatus.parsed?.data?.canUpdate === false &&
+          wikiStatus.parsed?.data?.suggestedAction === "create")),
+    reason: "agent_wiki_index_status"
+  });
+
+  const wikiChildren = runWave(["osmd", "wiki", "children"], env);
+  results.push(wikiChildren);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki children returns an array",
+    result: wikiChildren,
+    ok: wikiChildren.parsed?.ok === true && Array.isArray(wikiChildren.parsed?.data),
+    reason: "agent_wiki_children"
+  });
+
+  const wikiLogStatus = runWave(["osmd", "wiki", "status", "log.md"], env);
+  results.push(wikiLogStatus);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki status append-only log",
+    result: wikiLogStatus,
+    ok:
+      wikiLogStatus.parsed?.ok === true &&
+      wikiLogStatus.parsed?.data?.path === "Agent Wiki/log.md" &&
+      wikiLogStatus.parsed?.data?.source === "agent_wiki" &&
+      wikiLogStatus.parsed?.data?.access === "append_only" &&
+      wikiLogStatus.parsed?.data?.wikiRole === "log" &&
+      typeof wikiLogStatus.parsed?.data?.formatVersion === "string" &&
+      typeof wikiLogStatus.parsed?.data?.canAppend === "boolean",
+    reason: "agent_wiki_log_status"
+  });
+
+  const wikiLogRead = runWave(["osmd", "wiki", "read", "Agent Wiki/log.md"], env);
+  results.push(wikiLogRead);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki read append-only log does not create",
+    result: wikiLogRead,
+    ok:
+      wikiLogRead.parsed?.ok === true &&
+      wikiLogRead.parsed?.data?.path === "Agent Wiki/log.md" &&
+      wikiLogRead.parsed?.data?.access === "append_only" &&
+      wikiLogRead.parsed?.data?.wikiRole === "log" &&
+      typeof wikiLogRead.parsed?.data?.formatVersion === "string" &&
+      wikiLogRead.parsed?.data?.exists === wikiLogStatus.parsed?.data?.exists,
+    reason: "agent_wiki_log_read"
+  });
+
+  if (wikiLogStatus.parsed?.data?.exists === false) {
+    const missingWikiLogAppend = runWave(
+      ["osmd", "wiki", "append-log", "--content", `CLI live verify log ${verifyStamp}`],
+      env
+    );
+    results.push(missingWikiLogAppend);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: "osmd.wiki append-log missing log returns init guidance",
+      result: missingWikiLogAppend,
+      ok:
+        missingWikiLogAppend.parsed?.ok === false &&
+        missingWikiLogAppend.parsed?.status === 404 &&
+        missingWikiLogAppend.parsed?.error?.code === "agent_file_not_found" &&
+        missingWikiLogAppend.parsed?.error?.suggestedAction === "init" &&
+        String(missingWikiLogAppend.parsed?.error?.message ?? "").includes("wave osmd wiki init") &&
+        missingWikiLogAppend.parsed?.data?.path === "Agent Wiki/log.md" &&
+        missingWikiLogAppend.parsed?.data?.wikiRole === "log" &&
+        typeof missingWikiLogAppend.parsed?.data?.formatVersion === "string" &&
+        missingWikiLogAppend.parsed?.data?.canAppend === false,
+      reason: "agent_wiki_log_missing_init_guidance"
+    });
+  } else {
+    osmdVerificationLines.push(
+      "PASS | status=n/a | err=skipped_existing_log | reason=missing_log_init_guidance_skipped | osmd.wiki append-log missing log returns init guidance"
+    );
+  }
+
+  const wikiInit = runWave(["osmd", "wiki", "init"], env);
+  results.push(wikiInit);
+  const wikiInitFiles = firstArrayValue(wikiInit.parsed, [["data", "files"]]);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki init creates Agent Wiki system files",
+    result: wikiInit,
+    ok:
+      wikiInit.parsed?.ok === true &&
+      wikiInitFiles.some(
+        (file) =>
+          file?.path === "Agent Wiki/log.md" &&
+          file?.access === "append_only" &&
+          file?.wikiRole === "log" &&
+          typeof file?.formatVersion === "string" &&
+          file?.exists === true &&
+          file?.canAppend === true
+      ),
+    reason: "agent_wiki_init"
+  });
+
+  const wikiLogAppend = runWave(
+    ["osmd", "wiki", "append-log", "--content", `CLI live verify log ${verifyStamp}`],
+    env
+  );
+  results.push(wikiLogAppend);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki append-log succeeds after init",
+    result: wikiLogAppend,
+    ok:
+      wikiLogAppend.parsed?.ok === true &&
+      wikiLogAppend.parsed?.data?.path === "Agent Wiki/log.md" &&
+      wikiLogAppend.parsed?.data?.access === "append_only" &&
+      wikiLogAppend.parsed?.data?.wikiRole === "log" &&
+      typeof wikiLogAppend.parsed?.data?.formatVersion === "string" &&
+      wikiLogAppend.parsed?.data?.canAppend === true,
+    reason: "agent_wiki_log_append_after_init"
+  });
+
+  if (wikiStatus.parsed?.data?.exists === false) {
+    const missingWikiUpdate = runWave(
+      ["osmd", "wiki", "update", "index.md", "--content", "verify missing update"],
+      env
+    );
+    results.push(missingWikiUpdate);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: "osmd.wiki update missing file returns 404 metadata",
+      result: missingWikiUpdate,
+      ok:
+        missingWikiUpdate.code === 5 &&
+        missingWikiUpdate.parsed?.ok === false &&
+        missingWikiUpdate.parsed?.status === 404 &&
+        missingWikiUpdate.parsed?.error?.code === "agent_file_not_found" &&
+        missingWikiUpdate.parsed?.error?.suggestedAction === "create" &&
+        missingWikiUpdate.parsed?.data?.exists === false &&
+        missingWikiUpdate.parsed?.data?.canCreate === true &&
+        missingWikiUpdate.parsed?.data?.canUpdate === false &&
+        missingWikiUpdate.parsed?.data?.suggestedAction === "create",
+      reason: "missing_file_404"
+    });
+  } else {
+    osmdVerificationLines.push(
+      "PASS | status=n/a | err=skipped_existing_index | reason=missing_file_404_skipped | osmd.wiki update missing file returns 404 metadata"
+    );
+  }
+
+  const controlledWikiSearchTerm = `CLI live controlled wiki ${verifyStamp}`;
+  const controlledWikiPages = [
+    {
+      path: `concepts/cli-live-concept-${verifyStamp}.md`,
+      fullPath: `Agent Wiki/concepts/cli-live-concept-${verifyStamp}.md`,
+      wikiRole: "concept",
+      title: "concept"
+    },
+    {
+      path: `playbooks/cli-live-playbook-${verifyStamp}.md`,
+      fullPath: `Agent Wiki/playbooks/cli-live-playbook-${verifyStamp}.md`,
+      wikiRole: "playbook",
+      title: "playbook"
+    },
+    {
+      path: `decisions/cli-live-decision-${verifyStamp}.md`,
+      fullPath: `Agent Wiki/decisions/cli-live-decision-${verifyStamp}.md`,
+      wikiRole: "decision",
+      title: "decision"
+    },
+    {
+      path: `org-summaries/cli-live-org-summary-${verifyStamp}.md`,
+      fullPath: `Agent Wiki/org-summaries/cli-live-org-summary-${verifyStamp}.md`,
+      wikiRole: "org_summary",
+      title: "org_summary"
+    }
+  ];
+
+  for (const page of controlledWikiPages) {
+    const controlledStatus = runWave(["osmd", "wiki", "status", page.path], env);
+    results.push(controlledStatus);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: `osmd.wiki status controlled ${page.title}`,
+      result: controlledStatus,
+      ok:
+        controlledStatus.parsed?.ok === true &&
+        controlledStatus.parsed?.data?.path === page.fullPath &&
+        controlledStatus.parsed?.data?.source === "agent_wiki" &&
+        controlledStatus.parsed?.data?.access === "read_write" &&
+        controlledStatus.parsed?.data?.wikiRole === page.wikiRole &&
+        controlledStatus.parsed?.data?.formatVersion === "agent_markdown_v1" &&
+        controlledStatus.parsed?.data?.exists === false &&
+        controlledStatus.parsed?.data?.canCreate === true &&
+        controlledStatus.parsed?.data?.canUpdate === false &&
+        controlledStatus.parsed?.data?.canAppend === false &&
+        controlledStatus.parsed?.data?.suggestedAction === "create",
+      reason: "agent_wiki_controlled_status"
+    });
+
+    const createContent = `# CLI Live ${page.title}\n\n${controlledWikiSearchTerm} create ${page.title}`;
+    const controlledCreate = runWave(["osmd", "wiki", "create", page.path, "--content", createContent], env);
+    results.push(controlledCreate);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: `osmd.wiki create controlled ${page.title}`,
+      result: controlledCreate,
+      ok:
+        controlledCreate.parsed?.ok === true &&
+        controlledCreate.parsed?.data?.path === page.fullPath &&
+        controlledCreate.parsed?.data?.source === "agent_wiki" &&
+        controlledCreate.parsed?.data?.wikiRole === page.wikiRole &&
+        controlledCreate.parsed?.data?.formatVersion === "agent_markdown_v1" &&
+        controlledCreate.parsed?.data?.exists === true &&
+        controlledCreate.parsed?.data?.canUpdate === true &&
+        controlledCreate.parsed?.data?.canAppend === false &&
+        controlledCreate.parsed?.data?.content === createContent,
+      reason: "agent_wiki_controlled_create"
+    });
+
+    const updateContent = `# CLI Live ${page.title}\n\n${controlledWikiSearchTerm} update ${page.title}`;
+    const controlledUpdate = runWave(["osmd", "wiki", "update", page.path, "--content", updateContent], env);
+    results.push(controlledUpdate);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: `osmd.wiki update controlled ${page.title}`,
+      result: controlledUpdate,
+      ok:
+        controlledUpdate.parsed?.ok === true &&
+        controlledUpdate.parsed?.data?.path === page.fullPath &&
+        controlledUpdate.parsed?.data?.source === "agent_wiki" &&
+        controlledUpdate.parsed?.data?.wikiRole === page.wikiRole &&
+        controlledUpdate.parsed?.data?.formatVersion === "agent_markdown_v1" &&
+        controlledUpdate.parsed?.data?.exists === true &&
+        controlledUpdate.parsed?.data?.canUpdate === true &&
+        controlledUpdate.parsed?.data?.canAppend === false &&
+        controlledUpdate.parsed?.data?.content === updateContent,
+      reason: "agent_wiki_controlled_update"
+    });
+
+    const indexSummary = `CLI live index summary ${verifyStamp} ${page.title}`;
+    const controlledIndexUpsert = runWave(
+      ["osmd", "wiki", "index-upsert", page.path, "--summary", indexSummary],
+      env
+    );
+    results.push(controlledIndexUpsert);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: `osmd.wiki index-upsert controlled ${page.title}`,
+      result: controlledIndexUpsert,
+      ok:
+        controlledIndexUpsert.parsed?.ok === true &&
+        controlledIndexUpsert.parsed?.data?.path === "Agent Wiki/index.md" &&
+        controlledIndexUpsert.parsed?.data?.source === "agent_wiki" &&
+        controlledIndexUpsert.parsed?.data?.wikiRole === "index" &&
+        controlledIndexUpsert.parsed?.data?.formatVersion === "agent_markdown_v1" &&
+        controlledIndexUpsert.parsed?.data?.exists === true &&
+        controlledIndexUpsert.parsed?.data?.canUpdate === true &&
+        controlledIndexUpsert.parsed?.data?.canAppend === false &&
+        String(controlledIndexUpsert.parsed?.data?.content ?? "").includes(indexSummary),
+      reason: "agent_wiki_controlled_index_upsert"
+    });
+  }
+
+  const logIndexUpsertRejected = runWave(
+    ["osmd", "wiki", "index-upsert", "log.md", "--summary", "verify forbidden"],
+    env
+  );
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki index-upsert rejects log target",
+    result: logIndexUpsertRejected,
+    ok:
+      logIndexUpsertRejected.parsed?.ok === false &&
+      logIndexUpsertRejected.parsed?.status === 403 &&
+      logIndexUpsertRejected.parsed?.error?.code === "append_only_violation",
+    reason: "agent_wiki_index_upsert_log_reject"
+  });
+
+  const indexIndexUpsertRejected = runWave(
+    ["osmd", "wiki", "index-upsert", "index.md", "--summary", "verify forbidden"],
+    env
+  );
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki index-upsert rejects index target",
+    result: indexIndexUpsertRejected,
+    ok:
+      indexIndexUpsertRejected.parsed?.ok === false &&
+      indexIndexUpsertRejected.parsed?.status === 400 &&
+      indexIndexUpsertRejected.parsed?.error?.code === "invalid_args",
+    reason: "agent_wiki_index_upsert_index_reject"
+  });
+
+  const logCreateRejected = runWave(["osmd", "wiki", "create", "log.md", "--content", "verify forbidden"], env);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki create rejects log locally",
+    result: logCreateRejected,
+    ok:
+      logCreateRejected.parsed?.ok === false &&
+      logCreateRejected.parsed?.status === 400 &&
+      logCreateRejected.parsed?.error?.code === "invalid_args",
+    reason: "agent_wiki_log_create_local_reject"
+  });
+
+  const logUpdateRejected = runWave(["osmd", "wiki", "update", "log.md", "--content", "verify forbidden"], env);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki update rejects log locally",
+    result: logUpdateRejected,
+    ok:
+      logUpdateRejected.parsed?.ok === false &&
+      logUpdateRejected.parsed?.status === 400 &&
+      logUpdateRejected.parsed?.error?.code === "invalid_args",
+    reason: "agent_wiki_log_update_local_reject"
+  });
+
+  const arbitraryWikiRejected = runWave(
+    ["osmd", "wiki", "create", "random/cli-live-random.md", "--content", "verify forbidden"],
+    env
+  );
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.wiki create rejects arbitrary wiki path locally",
+    result: arbitraryWikiRejected,
+    ok:
+      arbitraryWikiRejected.parsed?.ok === false &&
+      arbitraryWikiRejected.parsed?.status === 400 &&
+      arbitraryWikiRejected.parsed?.error?.code === "invalid_args",
+    reason: "agent_wiki_arbitrary_path_local_reject"
+  });
+
+  const hardenedWikiRejectPaths = [
+    "Customer Health.md",
+    "customer_health.md",
+    "customer.health.md",
+    "concepts/Customer Health.md",
+    "concepts/customer_health.md",
+    "concepts/customer.health.md",
+    "concepts/nested/file.md"
+  ];
+  for (const path of hardenedWikiRejectPaths) {
+    const hardenedWikiRejected = runWave(["osmd", "wiki", "read", path], env);
+    osmdVerificationFailures += recordExactCheck({
+      lines: osmdVerificationLines,
+      label: `osmd.wiki read rejects invalid wiki path ${path}`,
+      result: hardenedWikiRejected,
+      ok:
+        hardenedWikiRejected.parsed?.ok === false &&
+        hardenedWikiRejected.parsed?.status === 400 &&
+        hardenedWikiRejected.parsed?.error?.code === "invalid_args",
+      reason: "agent_wiki_hardened_path_local_reject"
+    });
+  }
+
+  const parentRef = resolveOsmdAgentParentRef();
+  if (!parentRef) {
+    osmdVerificationLines.push(
+      "FAIL | status=n/a | err=osmd_parent_not_found | reason=no_agent_children_allowed_parent | osmd agent parent resolution"
+    );
+    osmdVerificationFailures += 1;
+    return;
+  }
+
+  const agentStatus = runWave(["osmd", "agent", "status", parentRef, "notes.md"], env);
+  results.push(agentStatus);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: `osmd.agent status notes parent=${parentRef}`,
+    result: agentStatus,
+    ok:
+      agentStatus.parsed?.ok === true &&
+      agentStatus.parsed?.data?.source === "agent_overlay" &&
+      agentStatus.parsed?.data?.wikiRole === "notes" &&
+      typeof agentStatus.parsed?.data?.formatVersion === "string" &&
+      agentStatus.parsed?.data?.parentRef === parentRef,
+    reason: "agent_overlay_status"
+  });
+
+  const agentInit = runWave(["osmd", "agent", "init", parentRef], env);
+  results.push(agentInit);
+  const initFiles = firstArrayValue(agentInit.parsed, [["data", "files"]]);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: `osmd.agent init parent=${parentRef}`,
+    result: agentInit,
+    ok:
+      agentInit.parsed?.ok === true &&
+      (initFiles.some(
+        (file) =>
+          file?.path?.endsWith("/.agent/notes.md") &&
+          file?.wikiRole === "notes" &&
+          typeof file?.formatVersion === "string"
+      ) ||
+        agentInit.parsed?.data?.path?.endsWith("/.agent/notes.md")),
+    reason: "agent_overlay_init"
+  });
+
+  const notesContent = `CLI live verify notes ${verifyStamp}`;
+  const agentUpdate = runWave(
+    ["osmd", "agent", "update", parentRef, "notes.md", "--content", notesContent],
+    env
+  );
+  results.push(agentUpdate);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: `osmd.agent update notes parent=${parentRef}`,
+    result: agentUpdate,
+    ok:
+      agentUpdate.parsed?.ok === true &&
+      agentUpdate.parsed?.data?.access === "read_write" &&
+      agentUpdate.parsed?.data?.wikiRole === "notes" &&
+      typeof agentUpdate.parsed?.data?.formatVersion === "string" &&
+      agentUpdate.parsed?.data?.content === notesContent,
+    reason: "agent_overlay_update"
+  });
+
+  const overlayIndexSummary = `CLI live overlay index summary ${verifyStamp}`;
+  const overlayIndexUpsert = runWave(
+    [
+      "osmd",
+      "wiki",
+      "index-upsert",
+      ".agent/notes.md",
+      "--parent-ref",
+      parentRef,
+      "--summary",
+      overlayIndexSummary
+    ],
+    env
+  );
+  results.push(overlayIndexUpsert);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: `osmd.wiki index-upsert overlay parent=${parentRef}`,
+    result: overlayIndexUpsert,
+    ok:
+      overlayIndexUpsert.parsed?.ok === true &&
+      overlayIndexUpsert.parsed?.data?.path === "Agent Wiki/index.md" &&
+      overlayIndexUpsert.parsed?.data?.source === "agent_wiki" &&
+      overlayIndexUpsert.parsed?.data?.wikiRole === "index" &&
+      overlayIndexUpsert.parsed?.data?.formatVersion === "agent_markdown_v1" &&
+      overlayIndexUpsert.parsed?.data?.exists === true &&
+      overlayIndexUpsert.parsed?.data?.canUpdate === true &&
+      overlayIndexUpsert.parsed?.data?.canAppend === false &&
+      String(overlayIndexUpsert.parsed?.data?.content ?? "").includes(parentRef) &&
+      String(overlayIndexUpsert.parsed?.data?.content ?? "").includes(overlayIndexSummary),
+    reason: "agent_overlay_index_upsert"
+  });
+
+  const searchCandidates = (result) => firstArrayValue(result.parsed, [["data", "candidates"]]);
+  const hasOwn = (candidate, key) => Object.prototype.hasOwnProperty.call(candidate ?? {}, key);
+  const hasSearchMetadata = (candidate, expectedSource) =>
+    candidate &&
+    typeof candidate.path === "string" &&
+    candidate.source === expectedSource &&
+    typeof candidate.access === "string" &&
+    typeof candidate.owner === "string" &&
+    hasOwn(candidate, "wikiRole") &&
+    hasOwn(candidate, "formatVersion") &&
+    hasOwn(candidate, "parentRef") &&
+    typeof candidate.exists === "boolean";
+
+  const canonicalSearch = runWave(["osmd", "search", "Wave Tools", "--scope", "os-only", "--limit", "5"], env);
+  results.push(canonicalSearch);
+  const canonicalSearchCandidates = searchCandidates(canonicalSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search canonical results include OS metadata",
+    result: canonicalSearch,
+    ok:
+      canonicalSearch.parsed?.ok === true &&
+      canonicalSearch.parsed?.command === "osmd.search" &&
+      typeof canonicalSearch.parsed?.meta?.requestId === "string" &&
+      canonicalSearch.parsed?.data?.scope === "canonical_osmd" &&
+      canonicalSearchCandidates.some(
+        (candidate) =>
+          hasSearchMetadata(candidate, "canonical_osmd") &&
+          candidate.access === "read_only" &&
+          candidate.owner === "system"
+      ),
+    reason: "osmd_search_canonical"
+  });
+
+  const wikiSearch = runWave(["osmd", "search", "Agent Wiki", "--scope", "agent-wiki-only", "--limit", "10"], env);
+  results.push(wikiSearch);
+  const wikiSearchCandidates = searchCandidates(wikiSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search Agent Wiki scope returns agent wiki metadata",
+    result: wikiSearch,
+    ok:
+      wikiSearch.parsed?.ok === true &&
+      wikiSearch.parsed?.data?.scope === "agent_wiki" &&
+      wikiSearchCandidates.length > 0 &&
+      wikiSearchCandidates.every(
+        (candidate) =>
+          hasSearchMetadata(candidate, "agent_wiki") &&
+          candidate.path.startsWith("Agent Wiki/") &&
+          candidate.owner === "atlas" &&
+          typeof candidate.toolKey === "string" &&
+          typeof candidate.nodeKey === "string" &&
+          typeof candidate.nodeKind === "string"
+      ),
+    reason: "osmd_search_agent_wiki"
+  });
+
+  const controlledWikiSearch = runWave(
+    ["osmd", "search", controlledWikiSearchTerm, "--scope", "agent-wiki-only", "--limit", "10"],
+    env
+  );
+  results.push(controlledWikiSearch);
+  const controlledWikiSearchCandidates = searchCandidates(controlledWikiSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search Agent Wiki controlled pages",
+    result: controlledWikiSearch,
+    ok:
+      controlledWikiSearch.parsed?.ok === true &&
+      controlledWikiSearch.parsed?.data?.scope === "agent_wiki" &&
+      controlledWikiPages.every((page) =>
+        controlledWikiSearchCandidates.some(
+          (candidate) =>
+            hasSearchMetadata(candidate, "agent_wiki") &&
+            candidate.path === page.fullPath &&
+            candidate.wikiRole === page.wikiRole &&
+            candidate.access === "read_write"
+        )
+      ),
+    reason: "osmd_search_agent_wiki_controlled_pages"
+  });
+
+  const controlledCombinedSearch = runWave(
+    ["osmd", "search", controlledWikiSearchTerm, "--scope", "combined", "--limit", "10"],
+    env
+  );
+  results.push(controlledCombinedSearch);
+  const controlledCombinedSearchCandidates = searchCandidates(controlledCombinedSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search combined includes controlled Agent Wiki pages",
+    result: controlledCombinedSearch,
+    ok:
+      controlledCombinedSearch.parsed?.ok === true &&
+      controlledCombinedSearch.parsed?.data?.scope === "combined" &&
+      controlledWikiPages.some((page) =>
+        controlledCombinedSearchCandidates.some(
+          (candidate) =>
+            hasSearchMetadata(candidate, "agent_wiki") &&
+            candidate.path === page.fullPath &&
+            candidate.wikiRole === page.wikiRole
+        )
+      ),
+    reason: "osmd_search_combined_controlled_pages"
+  });
+
+  const logSearch = runWave(
+    ["osmd", "search", `CLI live verify log ${verifyStamp}`, "--scope", "agent-wiki-only", "--limit", "5"],
+    env
+  );
+  results.push(logSearch);
+  const logSearchCandidates = searchCandidates(logSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search Agent Wiki log content result",
+    result: logSearch,
+    ok:
+      logSearch.parsed?.ok === true &&
+      logSearchCandidates.some(
+        (candidate) =>
+          hasSearchMetadata(candidate, "agent_wiki") &&
+          candidate.path === "Agent Wiki/log.md" &&
+          candidate.wikiRole === "log"
+      ),
+    reason: "osmd_search_agent_wiki_log"
+  });
+
+  const notesSearch = runWave(
+    ["osmd", "search", notesContent, "--scope", "agent-overlay-only", "--limit", "5"],
+    env
+  );
+  results.push(notesSearch);
+  const notesSearchCandidates = searchCandidates(notesSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search agent overlay notes content result",
+    result: notesSearch,
+    ok:
+      notesSearch.parsed?.ok === true &&
+      notesSearch.parsed?.data?.scope === "agent_overlay" &&
+      notesSearchCandidates.some(
+        (candidate) =>
+          hasSearchMetadata(candidate, "agent_overlay") &&
+          candidate.path.endsWith("/.agent/notes.md") &&
+          candidate.wikiRole === "notes" &&
+          candidate.parentRef === parentRef
+      ),
+    reason: "osmd_search_agent_overlay_notes"
+  });
+
+  const combinedSearch = runWave(["osmd", "search", "Wave", "--scope", "combined", "--limit", "3"], env);
+  results.push(combinedSearch);
+  osmdVerificationFailures += recordExactCheck({
+    lines: osmdVerificationLines,
+    label: "osmd.search combined scope returns stable envelope",
+    result: combinedSearch,
+    ok:
+      combinedSearch.parsed?.ok === true &&
+      combinedSearch.parsed?.command === "osmd.search" &&
+      combinedSearch.parsed?.data?.scope === "combined" &&
+      Array.isArray(combinedSearch.parsed?.data?.candidates) &&
+      typeof combinedSearch.parsed?.meta?.requestId === "string",
+    reason: "osmd_search_combined"
+  });
+
+}
+
+runOsmdLiveVerification();
+
+const lines = [];
+let failures = 0;
+for (const res of results) {
+  const verdict = classify(res);
+  const cmd = res.args.join(" ");
+  const status = res.parsed?.status ?? "n/a";
+  const errCode = res.parsed?.error?.code ?? "none";
+  const reasonDetail = verdict.details ? ` (${JSON.stringify(verdict.details)})` : "";
+  lines.push(
+    `${verdict.ok ? "PASS" : "FAIL"} | status=${status} | err=${errCode} | reason=${verdict.reason}${reasonDetail} | ${cmd}`
+  );
+  if (!verdict.ok) failures += 1;
+}
+
+if (deleteVerifyLine) {
+  lines.push(deleteVerifyLine);
+}
+failures += deleteVerifyFailure;
+if (postUpdateVerificationLines.length > 0) {
+  lines.push(...postUpdateVerificationLines);
+}
+failures += postUpdateVerificationFailures;
+if (osmdVerificationLines.length > 0) {
+  lines.push(...osmdVerificationLines);
+}
+failures += osmdVerificationFailures;
+failures += validationRemediationFailures;
+
+if (validationRemediationEntries.length > 0) {
+  lines.push("VALIDATION_REMEDIATION_SUMMARY_START");
+  for (const entry of validationRemediationEntries) {
+    lines.push(
+      [
+        "VALIDATION_REMEDIATION",
+        `operation=${entry.operation}`,
+        `offending_fields=${entry.offendingFields.join(",") || "n/a"}`,
+        `backend_message=${JSON.stringify(entry.backendMessage ?? "")}`,
+        `initial_result=${entry.initialResult}`,
+        `remediation=${entry.remediation}`,
+        `final_result=${entry.finalResult}`
+      ].join(" | ")
+    );
+  }
+  lines.push("VALIDATION_REMEDIATION_SUMMARY_END");
+}
+
+console.log(lines.join("\n"));
+const extraChecksCount =
+  (deleteVerifyLine ? 1 : 0) +
+  postUpdateVerificationLines.length +
+  validationRemediationEntries.length;
+console.log(`\nSUMMARY total=${results.length + extraChecksCount} failures=${failures}`);
+if (failures > 0) process.exit(1);