nemoris 0.1.0

package/src/runtime/output-contract-validator.js

@@ -0,0 +1,439 @@
+function normalizeText(value) {
+  return String(value || "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeInline(value) {
+  return normalizeText(value) || "None";
+}
+
+function normalizeSectionContent(value) {
+  if (Array.isArray(value)) {
+    const items = value.map((item) => normalizeText(item)).filter(Boolean);
+    return items.length ? items.join("; ") : "None";
+  }
+  if (value && typeof value === "object") {
+    const text = Object.values(value).map((item) => normalizeText(item)).filter(Boolean).join("; ");
+    return text || "None";
+  }
+  return normalizeInline(value);
+}
+
+function stripOuterFence(text) {
+  const raw = String(text || "").trim();
+  const fencedMatch = raw.match(/^```(?:json|markdown|md|text)?\s*([\s\S]*?)\s*```$/i);
+  return fencedMatch ? fencedMatch[1].trim() : raw;
+}
+
+function parseJsonCandidate(text) {
+  const candidate = stripOuterFence(text);
+  if (!(candidate.startsWith("{") && candidate.endsWith("}"))) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeSectionKey(value) {
+  return String(value || "")
+    .toLowerCase()
+    .replace(/^#+\s*/, "")
+    .replace(/[*:_-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+const SECTION_ALIASES = new Map([
+  ["project", "projects"],
+  ["next action", "next actions"]
+]);
+
+function canonicalSectionKey(value) {
+  const normalized = normalizeSectionKey(value);
+  return SECTION_ALIASES.get(normalized) || normalized;
+}
+
+function getContractRules(contract = null) {
+  const profile = contract?.profile || null;
+  return {
+    requireStatus: profile?.requireStatus ?? (contract?.format === "bulleted_briefing"),
+    sectionStyle: profile?.sectionStyle || (contract?.format === "structured_rollup" ? "headings" : "bullets"),
+    requireSectionItems: profile?.requireSectionItems ?? true
+  };
+}
+
+function parseObjectOutput(value, contract) {
+  const entries = Object.entries(value || {});
+  const sections = new Map();
+  let status = null;
+  const rules = getContractRules(contract);
+
+  for (const [key, entryValue] of entries) {
+    const normalizedKey = canonicalSectionKey(key);
+    const normalizedValue = normalizeSectionContent(entryValue);
+    if (normalizedKey === "status") {
+      status = normalizedValue;
+      continue;
+    }
+    sections.set(normalizedKey, normalizedValue);
+  }
+
+  if (rules.requireStatus && !status) {
+    status = "None";
+  }
+
+  return {
+    source: "object",
+    status,
+    sections,
+    bulletSections: rules.sectionStyle === "bullets" ? sections.size : 0,
+    headingSections: rules.sectionStyle === "headings" ? sections.size : 0
+  };
+}
+
+function buildCanonicalSections(contract, value, options = {}) {
+  const parsed = parseContractOutput(value, contract);
+  const requiredSections = contract?.requiredSections || [];
+  const sections = requiredSections.map((section) => {
+    const key = canonicalSectionKey(section);
+    return {
+      key,
+      label: section,
+      value: normalizeSectionContent(parsed.sections.get(key) || "None")
+    };
+  });
+
+  if (
+    contract?.format === "structured_rollup" &&
+    options.shadowOnlyEvidence &&
+    sections.every((section) => section.key === "update" || section.value === "None")
+  ) {
+    const updateSection = sections.find((section) => section.key === "update");
+    if (updateSection && updateSection.value === "None") {
+      updateSection.value = "Shadow import completed; monitor for new docs or memory before the next rollup.";
+    }
+  }
+
+  return {
+    parsed,
+    sections
+  };
+}
+
+export function renderContractOutput(contract, value, options = {}) {
+  if (!contract) return typeof value === "string" ? stripOuterFence(value) : normalizeSectionContent(value);
+
+  const { parsed, sections } = buildCanonicalSections(contract, value, options);
+  const rules = getContractRules(contract);
+
+  if (rules.sectionStyle === "headings") {
+    return sections
+      .map((section) => `## ${section.label.replace(/\b\w/g, (char) => char.toUpperCase())}\n- ${section.value}`)
+      .join("\n\n")
+      .trim();
+  }
+
+  const lines = [];
+  if (rules.requireStatus) {
+    lines.push(`Status: ${normalizeSectionContent(parsed.status || options.status || "None")}`);
+  }
+  for (const section of sections) {
+    lines.push(`- ${section.label.replace(/\b\w/g, (char) => char.toUpperCase())}: ${section.value}`);
+  }
+  return lines.join("\n").trim();
+}
+
+function parseBulletedBriefing(text) {
+  const lines = String(text || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const sections = new Map();
+  let status = null;
+  let bulletSections = 0;
+
+  for (const line of lines) {
+    const statusMatch = line.match(/^status:\s*(.+)$/i);
+    if (statusMatch) {
+      status = normalizeInline(statusMatch[1]);
+      continue;
+    }
+
+    const bulletMatch = line.match(/^[-*]\s+\**([^:*]+?)\**:\s*(.+)$/);
+    if (bulletMatch) {
+      sections.set(canonicalSectionKey(bulletMatch[1]), normalizeInline(bulletMatch[2]));
+      bulletSections += 1;
+      continue;
+    }
+
+    const plainMatch = line.match(/^([^:]{2,40}):\s*(.+)$/);
+    if (plainMatch) {
+      const key = canonicalSectionKey(plainMatch[1]);
+      const value = normalizeInline(plainMatch[2]);
+      if (key === "status") status = value;
+      else sections.set(key, value);
+    }
+  }
+
+  return {
+    source: "text",
+    status,
+    sections,
+    bulletSections,
+    headingSections: 0
+  };
+}
+
+function parseStructuredRollup(text) {
+  const lines = String(text || "")
+    .split("\n")
+    .map((line) => line.trim());
+  const sections = new Map();
+  let current = null;
+  let headingSections = 0;
+  let bulletSections = 0;
+
+  for (const line of lines) {
+    if (!line) continue;
+
+    const headingMatch = line.match(/^#{1,6}\s+(.+)$/);
+    if (headingMatch) {
+      current = canonicalSectionKey(headingMatch[1]);
+      if (!sections.has(current)) sections.set(current, []);
+      headingSections += 1;
+      continue;
+    }
+
+    const bulletMatch = line.match(/^[-*]\s+(.+)$/);
+    if (bulletMatch && current) {
+      sections.get(current).push(normalizeInline(bulletMatch[1]));
+      bulletSections += 1;
+      continue;
+    }
+
+    if (current) {
+      sections.get(current).push(normalizeInline(line));
+    }
+  }
+
+  const normalizedSections = new Map(
+    [...sections.entries()].map(([key, values]) => [key, values.filter(Boolean).join(" ") || "None"])
+  );
+
+  return {
+    source: "text",
+    status: null,
+    sections: normalizedSections,
+    bulletSections,
+    headingSections
+  };
+}
+
+export function parseContractOutput(value, contract = null) {
+  if (value == null) {
+    return {
+      source: "empty",
+      status: null,
+      sections: new Map(),
+      bulletSections: 0,
+      headingSections: 0
+    };
+  }
+
+  if (typeof value === "string") {
+    const parsed = parseJsonCandidate(value);
+    if (parsed && typeof parsed === "object") {
+      return parseContractOutput(parsed.output !== undefined ? parsed.output : parsed, contract);
+    }
+
+    const text = stripOuterFence(value);
+    const rules = getContractRules(contract);
+    if (rules.sectionStyle === "headings") {
+      return parseStructuredRollup(text);
+    }
+    return parseBulletedBriefing(text);
+  }
+
+  if (Array.isArray(value)) {
+    return parseContractOutput(value.join("\n"), contract);
+  }
+
+  if (typeof value === "object") {
+    return parseObjectOutput(value, contract);
+  }
+
+  return parseContractOutput(String(value), contract);
+}
+
+export function scoreFieldQuality(sectionContent) {
+  const raw = String(sectionContent || "");
+  const trimmed = raw.trim();
+  const lower = trimmed.toLowerCase();
+  const findings = [];
+  let score = 1;
+
+  if (!trimmed || lower === "none") {
+    return { score: 0, confidence: "none", findings: ["Section is empty or None"] };
+  }
+
+  if (/\[(title|link|summary|sub)\]|<brief update>|<one-line status>/i.test(trimmed)) {
+    findings.push("Section contains placeholder text");
+    score -= 0.5;
+  }
+
+  const labelStripped = trimmed.replace(/^[^:]{2,40}:\s*/, "");
+  if (labelStripped.length < 10) {
+    findings.push("Section content is very short");
+    score -= 0.15;
+  }
+
+  if (/\bsorry\b|\bcannot\b|\bfailed to\b|\bdoes not support\b/i.test(lower)) {
+    findings.push("Section contains apology or failure language");
+    score -= 0.3;
+  }
+
+  if (/timed out|timeout/i.test(lower)) {
+    findings.push("Section references a timeout");
+    score -= 0.35;
+  }
+
+  if (/^(no updates|nothing to report|n\/a|tbd|todo)$/i.test(lower) || /\bno updates\b|\bnothing to report\b/i.test(lower) && labelStripped.length < 25) {
+    findings.push("Section contains generic filler");
+    score -= 0.2;
+  }
+
+  score = Number(Math.max(0, Math.min(1, score)).toFixed(4));
+  let confidence;
+  if (score >= 0.8) confidence = "high";
+  else if (score >= 0.5) confidence = "medium";
+  else if (score > 0) confidence = "low";
+  else confidence = "none";
+
+  return { score, confidence, findings };
+}
+
+export function validateOutputContract(contract, value) {
+  if (!contract) return null;
+
+  const parsed = parseContractOutput(value, contract);
+  const requiredSections = contract.requiredSections || [];
+  const rules = getContractRules(contract);
+  const findings = [];
+  const sectionStates = requiredSections.map((section) => {
+    const normalizedSection = canonicalSectionKey(section);
+    const content = parsed.sections.get(normalizedSection) || null;
+    return {
+      section: normalizedSection,
+      present: parsed.sections.has(normalizedSection),
+      content,
+      nonEmpty: content != null && normalizeText(content).length > 0,
+      quality: scoreFieldQuality(content)
+    };
+  });
+
+  const missingSections = sectionStates.filter((state) => !state.present).map((state) => state.section);
+  const emptySections = sectionStates.filter((state) => state.present && !state.nonEmpty).map((state) => state.section);
+
+  if (missingSections.length) {
+    findings.push(`Missing required sections: ${missingSections.join(", ")}.`);
+  }
+  if (emptySections.length) {
+    findings.push(`Required sections are empty: ${emptySections.join(", ")}.`);
+  }
+
+  const formatSignals = {
+    source: parsed.source,
+    statusPresent: Boolean(parsed.status),
+    bulletSections: parsed.bulletSections,
+    headingSections: parsed.headingSections
+  };
+
+  if (rules.sectionStyle === "bullets") {
+    if (!formatSignals.statusPresent) {
+      findings.push("Bulleted briefing is missing a status line.");
+    }
+    if (rules.requireSectionItems && formatSignals.source === "text" && formatSignals.bulletSections < requiredSections.length) {
+      findings.push("Bulleted briefing does not render each required section as its own bullet.");
+    }
+  }
+
+  if (rules.sectionStyle === "headings") {
+    if (formatSignals.source === "text" && formatSignals.headingSections < requiredSections.length) {
+      findings.push("Structured rollup does not render each required section as its own heading.");
+    }
+    if (rules.requireSectionItems && formatSignals.source === "text" && formatSignals.bulletSections < requiredSections.length) {
+      findings.push("Structured rollup does not provide bullet content under each required section.");
+    }
+  }
+
+  const sectionRatio =
+    requiredSections.length === 0
+      ? 1
+      : Math.max(0, (requiredSections.length - missingSections.length - emptySections.length) / requiredSections.length);
+
+  let formatRatio = 1;
+  if (rules.sectionStyle === "bullets") {
+    const statusRatio = rules.requireStatus ? (formatSignals.statusPresent ? 1 : 0) : 1;
+    const bulletRatio =
+      requiredSections.length === 0 ? 1 : Math.min(1, formatSignals.bulletSections / requiredSections.length);
+    formatRatio = formatSignals.source === "text" ? (statusRatio + bulletRatio) / 2 : statusRatio;
+  }
+
+  if (rules.sectionStyle === "headings") {
+    if (formatSignals.source === "text") {
+      const headingRatio =
+        requiredSections.length === 0 ? 1 : Math.min(1, formatSignals.headingSections / requiredSections.length);
+      const bulletRatio = rules.requireSectionItems
+        ? requiredSections.length === 0
+          ? 1
+          : Math.min(1, formatSignals.bulletSections / requiredSections.length)
+        : 1;
+      formatRatio = (headingRatio + bulletRatio) / 2;
+    }
+  }
+
+  const satisfiedRatio = Number(Math.max(0, Math.min(sectionRatio, formatRatio)).toFixed(4));
+
+  const scores = {};
+  const weakFields = [];
+  const placeholderFields = [];
+  for (const state of sectionStates) {
+    scores[state.section] = state.quality;
+    if (state.quality.score < 0.5) weakFields.push(state.section);
+    if (state.quality.findings.some((f) => /placeholder/i.test(f))) placeholderFields.push(state.section);
+  }
+  const allScores = sectionStates.map((s) => s.quality.score);
+  const averageScore = allScores.length
+    ? Number((allScores.reduce((sum, v) => sum + v, 0) / allScores.length).toFixed(4))
+    : 0;
+
+  const fieldScores = {
+    scores,
+    averageScore,
+    weakFields,
+    placeholderFields
+  };
+
+  return {
+    format: contract.format || null,
+    requiredSections,
+    styleHints: contract.styleHints || [],
+    profile: contract.profile || null,
+    parsed: {
+      status: parsed.status,
+      sections: Object.fromEntries(parsed.sections),
+      formatSignals
+    },
+    sectionStates,
+    satisfiedRatio: Math.max(0, satisfiedRatio),
+    missingSections,
+    emptySections,
+    fieldScores,
+    findings
+  };
+}

package/src/runtime/peer-readiness.js

@@ -0,0 +1,69 @@
+import { OpenClawShadowBridge } from "../shadow/bridge.js";
+import { PeerRegistry } from "./peer-registry.js";
+
+function resolveNamedProfile(profiles, profileName) {
+  if (!profileName) return null;
+  return profiles[profileName] || profiles[String(profileName).replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())] || null;
+}
+
+export class PeerReadinessProbe {
+  constructor({ liveRoot } = {}) {
+    this.bridge = new OpenClawShadowBridge({ liveRoot });
+  }
+
+  async probe(runtime, peerId) {
+    const registry = new PeerRegistry(runtime.peers);
+    const peer = registry.get(peerId);
+    if (!peer) {
+      return {
+        peerId,
+        knownPeer: false,
+        routeResolvable: false,
+        targetReachable: false,
+        deliveryProfileValid: false,
+        readiness: "unknown_peer",
+        findings: ["Peer is not present in the trusted registry."]
+      };
+    }
+
+    const resolved = registry.resolveTarget({ mode: "peer_agent", peerId });
+    const deliveryProfile = resolved.deliveryProfile || runtime.delivery?.defaultPeerProfile || null;
+    const profileValid = Boolean(resolveNamedProfile(runtime.delivery?.profiles || {}, deliveryProfile));
+    const routeResolvable = Boolean(resolved.sessionKey);
+    let targetReachable;
+    const findings = [];
+
+    if (!profileValid) findings.push(`Delivery profile is missing: ${deliveryProfile || "(none)"}`);
+    if (!routeResolvable) findings.push("Peer route does not have a resolvable session key.");
+
+    if (this.bridge.available && peer.agentId) {
+      const sessionIndex = await this.bridge.loadSessionIndex(peer.agentId);
+      targetReachable = Boolean(resolved.sessionKey && sessionIndex?.[resolved.sessionKey]);
+      if (!targetReachable && routeResolvable) {
+        findings.push("Peer route is resolvable but not currently present in the live session index.");
+      }
+    } else {
+      targetReachable = routeResolvable && profileValid;
+    }
+
+    const readiness = !profileValid
+      ? "profile_invalid"
+      : !routeResolvable
+        ? "route_unresolvable"
+        : targetReachable
+          ? "ready"
+          : "route_only";
+
+    return {
+      peerId,
+      knownPeer: true,
+      routeResolvable,
+      targetReachable,
+      deliveryProfileValid: profileValid,
+      deliveryProfile,
+      sessionKey: resolved.sessionKey || null,
+      readiness,
+      findings
+    };
+  }
+}

package/src/runtime/peer-registry.js

@@ -0,0 +1,133 @@
+export class PeerRegistry {
+  constructor(config = {}) {
+    this.peers = config.peers || {};
+  }
+
+  get(peerId) {
+    return this.peers[peerId] || null;
+  }
+
+  list() {
+    return Object.entries(this.peers).map(([peerId, peer]) => ({
+      peerId,
+      ...peer
+    }));
+  }
+
+  listCards() {
+    return this.list()
+      .filter((peer) => peer.card)
+      .map((peer) => ({
+        peerId: peer.peerId,
+        agentId: peer.agentId || null,
+        label: peer.label || peer.peerId,
+        deliveryProfile: peer.deliveryProfile || null,
+        sessionKeys: peer.sessionKeys || [],
+        ...peer.card
+      }));
+  }
+
+  findByCapability(query) {
+    const terms = String(query || "")
+      .toLowerCase()
+      .split(/[^a-z0-9]+/i)
+      .filter(Boolean);
+    if (!terms.length) return this.listCards();
+
+    return this.listCards()
+      .map((card) => {
+        const haystack = [
+          card.label,
+          card.role,
+          card.mission,
+          ...(card.capabilityTags || []),
+          ...(card.preferredTaskClasses || [])
+        ]
+          .filter(Boolean)
+          .join(" ")
+          .toLowerCase();
+        const matches = terms.filter((term) => haystack.includes(term));
+        return {
+          ...card,
+          matchCount: matches.length
+        };
+      })
+      .filter((card) => card.matchCount > 0)
+      .sort((a, b) => b.matchCount - a.matchCount || a.label.localeCompare(b.label));
+  }
+
+  suggestPeers({ taskType = null, query = "", preferredDeliveryProfile = null, trustLevel = null, limit = 3 } = {}) {
+    const cards = this.listCards();
+    const queryTerms = String(query || "")
+      .toLowerCase()
+      .split(/[^a-z0-9]+/i)
+      .filter(Boolean);
+    const taskKey = String(taskType || "").toLowerCase().trim();
+
+    return cards
+      .map((card) => {
+        let score = 0;
+        const reasons = [];
+
+        if (taskKey && (card.preferredTaskClasses || []).map((item) => String(item).toLowerCase()).includes(taskKey)) {
+          score += 4;
+          reasons.push(`preferred task class:${taskKey}`);
+        }
+
+        const tagMatches = (card.capabilityTags || []).filter((tag) => queryTerms.includes(String(tag).toLowerCase()));
+        if (tagMatches.length) {
+          score += tagMatches.length * 3;
+          reasons.push(`capability tags:${tagMatches.join(",")}`);
+        }
+
+        const text = [card.role, card.mission, ...(card.capabilityTags || []), ...(card.preferredTaskClasses || [])]
+          .filter(Boolean)
+          .join(" ")
+          .toLowerCase();
+        const fuzzyMatches = queryTerms.filter((term) => text.includes(term) && !tagMatches.includes(term));
+        if (fuzzyMatches.length) {
+          score += fuzzyMatches.length;
+          reasons.push(`text match:${fuzzyMatches.join(",")}`);
+        }
+
+        if (preferredDeliveryProfile && (card.deliveryPreferences || []).includes(preferredDeliveryProfile)) {
+          score += 1;
+          reasons.push(`delivery:${preferredDeliveryProfile}`);
+        }
+
+        if (trustLevel && card.trustLevel === trustLevel) {
+          score += 1;
+          reasons.push(`trust:${trustLevel}`);
+        }
+
+        return {
+          ...card,
+          score,
+          reasons
+        };
+      })
+      .filter((card) => card.score > 0)
+      .sort((a, b) => b.score - a.score || a.label.localeCompare(b.label))
+      .slice(0, limit);
+  }
+
+  resolveTarget(target) {
+    if (!target || typeof target !== "object") return null;
+    if (target.mode !== "peer_agent") return null;
+
+    const peerId = target.peerId || target.agentId || null;
+    const peer = peerId ? this.get(peerId) : null;
+    if (!peer) {
+      throw new Error(`Unknown peer target ${peerId || "(missing peerId)"}`);
+    }
+
+    return {
+      peerId,
+      peer,
+      sessionKey: target.sessionKey || peer.sessionKeys?.[0] || null,
+      deliveryProfile: target.deliveryProfile || peer.deliveryProfile || null,
+      label: peer.label || peerId,
+      card: peer.card || null
+    };
+  }
+}